mir/vinyldns
2
0
Fork 0
mirror of https://github.com/VinylDNS/vinyldns synced 2025-08-31 22:35:19 +00:00
Code Issues Releases Wiki Activity

update

Browse Source
This commit is contained in:
Jay07GIT
2022-04-21 16:42:08 +05:30
parent 1205b7df2a
commit c82cbbdf66
3 changed files with 107 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
modules/mysql/src/it/scala/vinyldns/mysql/repository/MySqlRecordSetDataRepositoryIntegrationSpec.scala
View File

@@ -39,7 +39,9 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
import vinyldns.core.TestRecordSetData._ import vinyldns.core.TestRecordSetData._
import vinyldns.core.TestZoneData._ import vinyldns.core.TestZoneData._
private val repo = TestMySqlInstance.recordSetDataRepository.asInstanceOf[MySqlRecordSetDataRepository] private val recordSetDataRepo = TestMySqlInstance.recordSetDataRepository.asInstanceOf[MySqlRecordSetDataRepository]
private val recordSetRepo = TestMySqlInstance.recordSetRepository.asInstanceOf[MySqlRecordSetRepository]
override protected def beforeEach(): Unit = clear() override protected def beforeEach(): Unit = clear()
@@ -48,6 +50,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
def clear(): Unit = def clear(): Unit =
DB.localTx { s => DB.localTx { s =>
s.executeUpdate("DELETE FROM recordset_data") s.executeUpdate("DELETE FROM recordset_data")
s.executeUpdate("DELETE FROM recordset")
} }
def generateInserts(zone: Zone, count: Int, word: String = "insert"): List[RecordSetChange] = { def generateInserts(zone: Zone, count: Int, word: String = "insert"): List[RecordSetChange] = {
@@ -67,7 +70,9 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val pendingChanges = generateInserts(zone, count, word) val pendingChanges = generateInserts(zone, count, word)
val bigPendingChangeSet = ChangeSet(pendingChanges) val bigPendingChangeSet = ChangeSet(pendingChanges)
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, bigPendingChangeSet) recordSetDataRepo.save(db, bigPendingChangeSet)
recordSetRepo.apply(db, bigPendingChangeSet)
}.unsafeRunSync() }.unsafeRunSync()
pendingChanges pendingChanges
} }
@@ -75,7 +80,9 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
def insert(changes: List[RecordSetChange]): Unit = { def insert(changes: List[RecordSetChange]): Unit = {
val bigPendingChangeSet = ChangeSet(changes) val bigPendingChangeSet = ChangeSet(changes)
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, bigPendingChangeSet) recordSetDataRepo.save(db, bigPendingChangeSet)
recordSetRepo.apply(db, bigPendingChangeSet)
}.unsafeRunSync() }.unsafeRunSync()
() ()
} }
@@ -95,13 +102,14 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val deleteChange = makePendingTestDeleteChange(existing(1)) val deleteChange = makePendingTestDeleteChange(existing(1))
.copy(status = RecordSetChangeStatus.Failed) .copy(status = RecordSetChangeStatus.Failed)
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, ChangeSet(Seq(addChange, updateChange, deleteChange))) recordSetDataRepo.save(db, ChangeSet(Seq(addChange, updateChange, deleteChange)))
recordSetRepo.apply(db, ChangeSet(Seq(addChange, updateChange, deleteChange)))
} }
repo.getRecordSetData(rsOk.id).unsafeRunSync() shouldBe None recordSetDataRepo.getRecordSetData(rsOk.id).unsafeRunSync() shouldBe None
repo.getRecordSetData(existing.head.id).unsafeRunSync() shouldBe Some( recordSetDataRepo.getRecordSetData(existing.head.id).unsafeRunSync() shouldBe Some(
recordSetDataWithFQDN(existing.head, okZone) recordSetDataWithFQDN(existing.head, okZone)
) )
repo.getRecordSetData(existing(1).id).unsafeRunSync() shouldBe Some( recordSetDataRepo.getRecordSetData(existing(1).id).unsafeRunSync() shouldBe Some(
recordSetDataWithFQDN(existing(1), okZone) recordSetDataWithFQDN(existing(1), okZone)
) )
} }
@@ -153,29 +161,31 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
status = RecordSetChangeStatus.Pending status = RecordSetChangeStatus.Pending
) )
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, ChangeSet(existingPending)) recordSetDataRepo.save(db, ChangeSet(existingPending))
recordSetRepo.apply(db, ChangeSet(existingPending))
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
repo.getRecordSetData(failedChange.recordSet.id).unsafeRunSync() shouldBe recordSetDataRepo.getRecordSetData(failedChange.recordSet.id).unsafeRunSync() shouldBe
Some( Some(
existingPending.recordSet existingPending.recordSet
.copy(fqdn = Some(s"""${failedChange.recordSet.name}.${okZone.name}""")) .copy(fqdn = Some(s"""${failedChange.recordSet.name}.${okZone.name}"""))
) )
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, ChangeSet(Seq(successfulChange, pendingChange, failedChange))) recordSetDataRepo.save(db, ChangeSet(Seq(successfulChange, pendingChange, failedChange)))
recordSetRepo.apply(db, ChangeSet(Seq(successfulChange, pendingChange, failedChange)))
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
// success and pending changes have records saved // success and pending changes have records saved
repo recordSetDataRepo
.getRecordSetData(successfulChange.recordSet.id) .getRecordSetData(successfulChange.recordSet.id)
.unsafeRunSync() shouldBe .unsafeRunSync() shouldBe
Some(recordSetDataWithFQDN(successfulChange.recordSet, okZone)) Some(recordSetDataWithFQDN(successfulChange.recordSet, okZone))
repo recordSetDataRepo
.getRecordSetData(pendingChange.recordSet.id) .getRecordSetData(pendingChange.recordSet.id)
.unsafeRunSync() shouldBe .unsafeRunSync() shouldBe
Some(recordSetDataWithFQDN(pendingChange.recordSet, okZone)) Some(recordSetDataWithFQDN(pendingChange.recordSet, okZone))
// check that the pending record was deleted because of failed record change // check that the pending record was deleted because of failed record change
repo recordSetDataRepo
.getRecordSetData(failedChange.recordSet.id) .getRecordSetData(failedChange.recordSet.id)
.unsafeRunSync() shouldBe None .unsafeRunSync() shouldBe None
} }
@@ -185,8 +195,10 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val pendingChanges = generateInserts(okZone, 1000) val pendingChanges = generateInserts(okZone, 1000)
val bigPendingChangeSet = ChangeSet(pendingChanges) val bigPendingChangeSet = ChangeSet(pendingChanges)
val saveRecSets = executeWithinTransaction { db: DB => val saveRecSets = executeWithinTransaction { db: DB =>
repo.save(db, bigPendingChangeSet) recordSetDataRepo.save(db, bigPendingChangeSet)
repo.save(db, bigPendingChangeSet) recordSetDataRepo.save(db, bigPendingChangeSet)
recordSetRepo.apply(db, bigPendingChangeSet)
recordSetRepo.apply(db, bigPendingChangeSet)
} }
saveRecSets.attempt.unsafeRunSync() shouldBe right saveRecSets.attempt.unsafeRunSync() shouldBe right
} }
@@ -195,10 +207,12 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val bigPendingChangeSet = ChangeSet(pendingChanges) val bigPendingChangeSet = ChangeSet(pendingChanges)
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, bigPendingChangeSet) recordSetDataRepo.save(db, bigPendingChangeSet)
recordSetRepo.apply(db, bigPendingChangeSet)
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
// let's make sure we have all 1000 records // let's make sure we have all 1000 records
val recordCount = repo.getRecordSetDataCount(okZone.id).unsafeRunSync() val recordCount = recordSetDataRepo.getRecordSetDataCount(okZone.id).unsafeRunSync()
recordCount shouldBe 20 recordCount shouldBe 20
} }
"work for deletes, updates, and inserts" in { "work for deletes, updates, and inserts" in {
@@ -222,29 +236,31 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
// exercise the entire change set // exercise the entire change set
val cs = ChangeSet(deletes ++ updates ++ inserts) val cs = ChangeSet(deletes ++ updates ++ inserts)
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, cs) recordSetDataRepo.save(db, cs)
recordSetRepo.apply(db, cs)
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
// make sure the deletes are gone // make sure the deletes are gone
repo.getRecordSetData(deletes(0).recordSet.id).unsafeRunSync() shouldBe None recordSetDataRepo.getRecordSetData(deletes(0).recordSet.id).unsafeRunSync() shouldBe None
repo.getRecordSetData(deletes(1).recordSet.id).unsafeRunSync() shouldBe None recordSetDataRepo.getRecordSetData(deletes(1).recordSet.id).unsafeRunSync() shouldBe None
// make sure the updates are updated // make sure the updates are updated
repo.getRecordSetData(updates(0).recordSet.id).unsafeRunSync().map(_.name) shouldBe recordSetDataRepo.getRecordSetData(updates(0).recordSet.id).unsafeRunSync().map(_.name) shouldBe
Some(updates(0).recordSet.name) Some(updates(0).recordSet.name)
repo.getRecordSetData(updates(1).recordSet.id).unsafeRunSync().map(_.name) shouldBe recordSetDataRepo.getRecordSetData(updates(1).recordSet.id).unsafeRunSync().map(_.name) shouldBe
Some(updates(1).recordSet.name) Some(updates(1).recordSet.name)
// make sure the new ones are there // make sure the new ones are there
repo.getRecordSetData(inserts(0).recordSet.id).unsafeRunSync().map(_.name) shouldBe recordSetDataRepo.getRecordSetData(inserts(0).recordSet.id).unsafeRunSync().map(_.name) shouldBe
Some(inserts(0).recordSet.name) Some(inserts(0).recordSet.name)
repo.getRecordSetData(inserts(1).recordSet.id).unsafeRunSync().map(_.name) shouldBe recordSetDataRepo.getRecordSetData(inserts(1).recordSet.id).unsafeRunSync().map(_.name) shouldBe
Some(inserts(1).recordSet.name) Some(inserts(1).recordSet.name)
} }
} }
"list record sets" should { "list record sets" should {
"return all record sets in a zone when optional params are not set" in { "return all record sets in a zone when optional params are not set" in {
val existing = insert(okZone, 10).map(_.recordSet) val existing = insert(okZone, 10).map(_.recordSet)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, None, None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, None, None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
found.recordSets should contain theSameElementsAs existing.map( found.recordSets should contain theSameElementsAs existing.map(
@@ -255,7 +271,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
// load 5, start after the 3rd, we should get back the last two // load 5, start after the 3rd, we should get back the last two
val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name) val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name)
val startFrom = Some(PagingKey.toNextId(existing(2), true)) val startFrom = Some(PagingKey.toNextId(existing(2), true))
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), startFrom, None, None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), startFrom, None, None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
@@ -269,7 +285,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
// load 5, start after the 2nd, take 2, we should get back the 3rd and 4th // load 5, start after the 2nd, take 2, we should get back the 3rd and 4th
val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name) val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name)
val startFrom = Some(PagingKey.toNextId(existing(1), true)) val startFrom = Some(PagingKey.toNextId(existing(1), true))
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), startFrom, Some(2), None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), startFrom, Some(2), None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
@@ -293,7 +309,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
insert(changes) insert(changes)
val startFrom = Some(PagingKey.toNextId(newRecordSets(1), true)) val startFrom = Some(PagingKey.toNextId(newRecordSets(1), true))
val found = repo val found = recordSetDataRepo
.listRecordSetData( .listRecordSetData(
Some(okZone.id), Some(okZone.id),
startFrom, startFrom,
@@ -318,7 +334,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val changes = newRecordSets.map(makeTestAddChange(_, okZone)) val changes = newRecordSets.map(makeTestAddChange(_, okZone))
insert(changes) insert(changes)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, Some(3), Some("aa*"), None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, Some(3), Some("aa*"), None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames) (found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames)
@@ -335,7 +351,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val changes = newRecordSets.map(makeTestAddChange(_, okZone)) val changes = newRecordSets.map(makeTestAddChange(_, okZone))
insert(changes) insert(changes)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, Some(3), Some("*b"), None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, Some(3), Some("*b"), None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames) (found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames)
@@ -353,14 +369,14 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val changes = newRecordSets.map(makeTestAddChange(_, okZone)) val changes = newRecordSets.map(makeTestAddChange(_, okZone))
insert(changes) insert(changes)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, Some(3), Some("aaa"), None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, Some(3), Some("aaa"), None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames) (found.recordSets.map(_.name) should contain).theSameElementsInOrderAs(expectedNames)
} }
"return select types of recordsets in a zone" in { "return select types of recordsets in a zone" in {
insert(okZone, 10).map(_.recordSet) insert(okZone, 10).map(_.recordSet)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, None, None, Some(Set(CNAME)), None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, None, None, Some(Set(CNAME)), None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
found.recordSets shouldBe List() found.recordSets shouldBe List()
@@ -368,7 +384,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
} }
"return all recordsets in a zone in descending order" in { "return all recordsets in a zone in descending order" in {
val existing = insert(okZone, 10).map(_.recordSet) val existing = insert(okZone, 10).map(_.recordSet)
val found = repo val found = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, None, None, None, None, NameSort.DESC) .listRecordSetData(Some(okZone.id), None, None, None, None, None, NameSort.DESC)
.unsafeRunSync() .unsafeRunSync()
found.recordSets should contain theSameElementsAs existing.map( found.recordSets should contain theSameElementsAs existing.map(
@@ -379,7 +395,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
"pages through the list properly" in { "pages through the list properly" in {
// load 5 records, pages of 2, last page should have 1 result and no next id // load 5 records, pages of 2, last page should have 1 result and no next id
val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name) val existing = insert(okZone, 5).map(_.recordSet).sortBy(_.name)
val page1 = repo val page1 = recordSetDataRepo
.listRecordSetData(Some(okZone.id), None, Some(2), None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), None, Some(2), None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(page1.recordSets should contain).theSameElementsInOrderAs( (page1.recordSets should contain).theSameElementsInOrderAs(
@@ -389,7 +405,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
) )
page1.nextId shouldBe Some(PagingKey.toNextId(page1.recordSets(1), true)) page1.nextId shouldBe Some(PagingKey.toNextId(page1.recordSets(1), true))
val page2 = repo val page2 = recordSetDataRepo
.listRecordSetData(Some(okZone.id), page1.nextId, Some(2), None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), page1.nextId, Some(2), None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(page2.recordSets should contain).theSameElementsInOrderAs( (page2.recordSets should contain).theSameElementsInOrderAs(
@@ -399,7 +415,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
) )
page2.nextId shouldBe Some(PagingKey.toNextId(page2.recordSets(1), true)) page2.nextId shouldBe Some(PagingKey.toNextId(page2.recordSets(1), true))
val page3 = repo val page3 = recordSetDataRepo
.listRecordSetData(Some(okZone.id), page2.nextId, Some(2), None, None, None, NameSort.ASC) .listRecordSetData(Some(okZone.id), page2.nextId, Some(2), None, None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
(page3.recordSets should contain).theSameElementsInOrderAs( (page3.recordSets should contain).theSameElementsInOrderAs(
@@ -412,7 +428,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
"return applicable recordsets in ascending order when recordNameFilter is given" in { "return applicable recordsets in ascending order when recordNameFilter is given" in {
val existing = insert(okZone, 10).map(_.recordSet) val existing = insert(okZone, 10).map(_.recordSet)
val found = repo val found = recordSetDataRepo
.listRecordSetData(None, None, None, Some("*.ok*"), None, None, NameSort.ASC) .listRecordSetData(None, None, None, Some("*.ok*"), None, None, NameSort.ASC)
.unsafeRunSync() .unsafeRunSync()
found.recordSets should contain theSameElementsAs existing.map( found.recordSets should contain theSameElementsAs existing.map(
@@ -421,7 +437,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
} }
"return applicable recordsets in descending order when recordNameFilter is given and name sort is descending" in { "return applicable recordsets in descending order when recordNameFilter is given and name sort is descending" in {
val existing = insert(okZone, 10).map(_.recordSet) val existing = insert(okZone, 10).map(_.recordSet)
val found = repo val found = recordSetDataRepo
.listRecordSetData(None, None, None, Some("*.ok*"), None, None, NameSort.DESC) .listRecordSetData(None, None, None, Some("*.ok*"), None, None, NameSort.DESC)
.unsafeRunSync() .unsafeRunSync()
found.recordSets should contain theSameElementsAs existing found.recordSets should contain theSameElementsAs existing
@@ -430,7 +446,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
} }
"return no recordsets when no zoneId or recordNameFilter are given" in { "return no recordsets when no zoneId or recordNameFilter are given" in {
val found = val found =
repo.listRecordSetData(None, None, None, None, None, None, NameSort.ASC).unsafeRunSync() recordSetDataRepo.listRecordSetData(None, None, None, None, None, None, NameSort.ASC).unsafeRunSync()
found.recordSets shouldBe empty found.recordSets shouldBe empty
} }
} }
@@ -438,31 +454,31 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
"return a record set when there is a match" in { "return a record set when there is a match" in {
val existing = insert(okZone, 1).map(_.recordSet) val existing = insert(okZone, 1).map(_.recordSet)
val results = val results =
repo.getRecordSetDataList(okZone.id, existing.head.name, existing.head.typ).unsafeRunSync() recordSetDataRepo.getRecordSetDataList(okZone.id, existing.head.name, existing.head.typ).unsafeRunSync()
results.headOption shouldBe Some(recordSetDataWithFQDN(existing.head, okZone)) results.headOption shouldBe Some(recordSetDataWithFQDN(existing.head, okZone))
} }
"return none when there is no match" in { "return none when there is no match" in {
val existing = insert(okZone, 1).map(_.recordSet) val existing = insert(okZone, 1).map(_.recordSet)
val results = repo.getRecordSetDataList(okZone.id, "not-there", existing.head.typ).unsafeRunSync() val results = recordSetDataRepo.getRecordSetDataList(okZone.id, "not-there", existing.head.typ).unsafeRunSync()
results shouldBe empty results shouldBe empty
} }
} }
"get record set by id" should { "get record set by id" should {
"return a record set when there is a match" in { "return a record set when there is a match" in {
val existing = insert(okZone, 1).map(_.recordSet) val existing = insert(okZone, 1).map(_.recordSet)
val result = repo.getRecordSetData(existing.head.id).unsafeRunSync() val result = recordSetDataRepo.getRecordSetData(existing.head.id).unsafeRunSync()
result shouldBe Some(recordSetDataWithFQDN(existing.head, okZone)) result shouldBe Some(recordSetDataWithFQDN(existing.head, okZone))
} }
"return none when there is no match" in { "return none when there is no match" in {
insert(okZone, 1).map(_.recordSet) insert(okZone, 1).map(_.recordSet)
val result = repo.getRecordSetData("not-there").unsafeRunSync() val result = recordSetDataRepo.getRecordSetData("not-there").unsafeRunSync()
result shouldBe None result shouldBe None
} }
} }
"get record set count for zone" should { "get record set count for zone" should {
"return the correct number of records in the zone" in { "return the correct number of records in the zone" in {
insert(okZone, 10) insert(okZone, 10)
repo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 10 recordSetDataRepo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 10
} }
} }
"get record sets by name" should { "get record sets by name" should {
@@ -474,14 +490,15 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val changes = newRecordSets.map(makeTestAddChange(_, okZone)) val changes = newRecordSets.map(makeTestAddChange(_, okZone))
val expected = changes.map(r => recordSetDataWithFQDN(r.recordSet, okZone)) val expected = changes.map(r => recordSetDataWithFQDN(r.recordSet, okZone))
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.save(db, ChangeSet(changes)) recordSetDataRepo.save(db, ChangeSet(changes))
recordSetRepo.apply(db, ChangeSet(changes))
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
val results = repo.getRecordSetDataByName(okZone.id, "foo").unsafeRunSync() val results = recordSetDataRepo.getRecordSetDataByName(okZone.id, "foo").unsafeRunSync()
results should contain theSameElementsAs expected results should contain theSameElementsAs expected
} }
"return none when there is no match" in { "return none when there is no match" in {
insert(okZone, 1).map(_.recordSet) insert(okZone, 1).map(_.recordSet)
val results = repo.getRecordSetDataByName(okZone.id, "not-there").unsafeRunSync() val results = recordSetDataRepo.getRecordSetDataByName(okZone.id, "not-there").unsafeRunSync()
results shouldBe empty results shouldBe empty
} }
} }
@@ -497,7 +514,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val change2 = makeTestAddChange(aaaa.copy(name = rname2), okZone) val change2 = makeTestAddChange(aaaa.copy(name = rname2), okZone)
insert(List(change1, change2)) insert(List(change1, change2))
val result = repo.getRecordSetDataListByFQDNs(Set("no-existo", fqdn1, fqdn2)).unsafeRunSync() val result = recordSetDataRepo.getRecordSetDataListByFQDNs(Set("no-existo", fqdn1, fqdn2)).unsafeRunSync()
result should contain theSameElementsAs List( result should contain theSameElementsAs List(
recordSetDataWithFQDN(change1.recordSet, okZone), recordSetDataWithFQDN(change1.recordSet, okZone),
recordSetDataWithFQDN(change2.recordSet, okZone) recordSetDataWithFQDN(change2.recordSet, okZone)
@@ -512,7 +529,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val mxChange = makeTestAddChange(mx.copy(name = rname), okZone) val mxChange = makeTestAddChange(mx.copy(name = rname), okZone)
insert(List(aaaaChange, mxChange)) insert(List(aaaaChange, mxChange))
val result = repo.getRecordSetDataListByFQDNs(Set(fqdn)).unsafeRunSync() val result = recordSetDataRepo.getRecordSetDataListByFQDNs(Set(fqdn)).unsafeRunSync()
result should contain theSameElementsAs List( result should contain theSameElementsAs List(
recordSetDataWithFQDN(aaaaChange.recordSet, okZone), recordSetDataWithFQDN(aaaaChange.recordSet, okZone),
recordSetDataWithFQDN(mxChange.recordSet, okZone) recordSetDataWithFQDN(mxChange.recordSet, okZone)
@@ -520,7 +537,7 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
} }
"return an empty list when given no ids" in { "return an empty list when given no ids" in {
val result = repo.getRecordSetDataListByFQDNs(Set[String]()).unsafeRunSync() val result = recordSetDataRepo.getRecordSetDataListByFQDNs(Set[String]()).unsafeRunSync()
result shouldBe List() result shouldBe List()
} }
@@ -535,12 +552,12 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val change2 = makeTestAddChange(mx.copy(name = rname2), okZone) val change2 = makeTestAddChange(mx.copy(name = rname2), okZone)
insert(List(change1, change2)) insert(List(change1, change2))
val result1 = repo.getRecordSetDataListByFQDNs(Set(fqdn1)).unsafeRunSync() val result1 = recordSetDataRepo.getRecordSetDataListByFQDNs(Set(fqdn1)).unsafeRunSync()
result1 should contain theSameElementsAs List( result1 should contain theSameElementsAs List(
recordSetDataWithFQDN(change1.recordSet, okZone), recordSetDataWithFQDN(change1.recordSet, okZone),
recordSetDataWithFQDN(change2.recordSet, okZone) recordSetDataWithFQDN(change2.recordSet, okZone)
) )
val result2 = repo.getRecordSetDataListByFQDNs(Set(fqdn2)).unsafeRunSync() val result2 = recordSetDataRepo.getRecordSetDataListByFQDNs(Set(fqdn2)).unsafeRunSync()
result2 should contain theSameElementsAs List( result2 should contain theSameElementsAs List(
recordSetDataWithFQDN(change1.recordSet, okZone), recordSetDataWithFQDN(change1.recordSet, okZone),
recordSetDataWithFQDN(change2.recordSet, okZone) recordSetDataWithFQDN(change2.recordSet, okZone)
@@ -554,17 +571,18 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
val testRecord = addChange.recordSet val testRecord = addChange.recordSet
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
for { for {
_ <- repo.save(db, ChangeSet(addChange)) _ <- recordSetDataRepo.save(db, ChangeSet(addChange))
get <- repo.getRecordSetData(testRecord.id) _ <- recordSetRepo.apply(db, ChangeSet(addChange))
get <- recordSetDataRepo.getRecordSetData(testRecord.id)
} yield get } yield get
}.attempt.unsafeRunSync() }.attempt.unsafeRunSync()
val result = repo.getFirstOwnedRecordSetDataByGroup("someOwner").unsafeRunSync() val result = recordSetDataRepo.getFirstOwnedRecordSetDataByGroup("someOwner").unsafeRunSync()
result shouldBe Some(testRecord.id) result shouldBe Some(testRecord.id)
} }
"return empty string when no record set has the id as ownerGroupId" in { "return empty string when no record set has the id as ownerGroupId" in {
val result = repo.getFirstOwnedRecordSetDataByGroup("notFound").unsafeRunSync() val result = recordSetDataRepo.getFirstOwnedRecordSetDataByGroup("notFound").unsafeRunSync()
result shouldBe None result shouldBe None
} }
} }
@@ -574,19 +592,19 @@ class MySqlRecordSetDataRepositoryIntegrationSpec
insert(okZone, 20) insert(okZone, 20)
insert(abcZone, 10) insert(abcZone, 10)
repo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 20 recordSetDataRepo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 20
repo.getRecordSetDataCount(abcZone.id).unsafeRunSync() shouldBe 10 recordSetDataRepo.getRecordSetDataCount(abcZone.id).unsafeRunSync() shouldBe 10
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.deleteRecordSetDataInZone(db, okZone.id, okZone.name)}.unsafeRunSync() should not be a[Throwable] recordSetDataRepo.deleteRecordSetDataInZone(db, okZone.id, okZone.name)}.unsafeRunSync() should not be a[Throwable]
repo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 0 recordSetDataRepo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 0
repo.getRecordSetDataCount(abcZone.id).unsafeRunSync() shouldBe 10 recordSetDataRepo.getRecordSetDataCount(abcZone.id).unsafeRunSync() shouldBe 10
} }
"not fail if there is nothing to delete" in { "not fail if there is nothing to delete" in {
repo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 0 recordSetDataRepo.getRecordSetDataCount(okZone.id).unsafeRunSync() shouldBe 0
executeWithinTransaction { db: DB => executeWithinTransaction { db: DB =>
repo.deleteRecordSetDataInZone(db,okZone.id, okZone.name)}.unsafeRunSync() should not be a[Throwable] recordSetDataRepo.deleteRecordSetDataInZone(db,okZone.id, okZone.name)}.unsafeRunSync() should not be a[Throwable]
} }
} }
} }

8
modules/mysql/src/main/resources/db/migration/V3.26__RecordSetData_RecordName_OwnerGroup.sql
View File

@@ -2,12 +2,6 @@ CREATE SCHEMA IF NOT EXISTS ${dbName};
USE ${dbName}; USE ${dbName};
ALTER TABLE recordset_data ADD COLUMN record_name VARCHAR(256) AFTER zone_id;
CREATE INDEX recordset_data_record_name_index ON recordset_data (record_name);
ALTER TABLE recordset_data ADD COLUMN owner_group_id CHAR(36) AFTER ip;
CREATE INDEX recordset_data_owner_group_id_index ON recordset_data (owner_group_id);
/* /*
Drop recordset_data_fdqn_fulltext_index index from recordset_data table Drop recordset_data_fdqn_fulltext_index index from recordset_data table
*/ */
@@ -24,3 +18,5 @@ Drop data column from recordset_data table
*/ */
ALTER TABLE recordset_data DROP COLUMN data; ALTER TABLE recordset_data DROP COLUMN data;

61
modules/mysql/src/main/scala/vinyldns/mysql/repository/MySqlRecordSetDataRepository.scala
View File

@@ -36,7 +36,7 @@ class MySqlRecordSetDataRepository
with ProtobufConversions { with ProtobufConversions {
private val INSERT_RECORDSETDATA = private val INSERT_RECORDSETDATA =
sql"INSERT IGNORE INTO recordset_data(recordset_id, zone_id, record_name, fqdn, reverse_fqdn, type, record_data, ip, owner_group_id) VALUES ({recordset_id}, {zone_id}, {record_name}, {fqdn}, {reverse_fqdn}, {type}, {record_data}, {ip}, {owner_group_id})" sql"INSERT IGNORE INTO recordset_data(recordset_id, zone_id, fqdn, reverse_fqdn, type, record_data, ip) VALUES ({recordset_id}, {zone_id}, {fqdn}, {reverse_fqdn}, {type}, {record_data}, {ip})"
private val DELETE_RECORDSETDATA = private val DELETE_RECORDSETDATA =
sql"DELETE FROM recordset_data WHERE recordset_id = ?" sql"DELETE FROM recordset_data WHERE recordset_id = ?"
@@ -48,12 +48,11 @@ class MySqlRecordSetDataRepository
sql""" sql"""
|SELECT count(*) |SELECT count(*)
| FROM recordset_data | FROM recordset_data
| INNER JOIN recordset ON recordset.id=recordset_data.recordset_id | WHERE zone_id = {zone_id}
| WHERE recordset_data.zone_id = {zone_id}
""".stripMargin """.stripMargin
private val BASE_FIND_RECORDSETS_BY_FQDNS = private val BASE_FIND_RECORDSETS_BY_FQDNS =
""" sql"""
|SELECT recordset.data, recordset_data.fqdn |SELECT recordset.data, recordset_data.fqdn
| FROM recordset_data | FROM recordset_data
| INNER JOIN recordset ON recordset.id=recordset_data.recordset_id | INNER JOIN recordset ON recordset.id=recordset_data.recordset_id
@@ -65,7 +64,7 @@ class MySqlRecordSetDataRepository
|SELECT recordset.data, recordset_data.fqdn |SELECT recordset.data, recordset_data.fqdn
| FROM recordset_data | FROM recordset_data
| INNER JOIN recordset ON recordset.id=recordset_data.recordset_id | INNER JOIN recordset ON recordset.id=recordset_data.recordset_id
| WHERE recordset_data.zone_id = {zone_id} AND recordset_data.record_name = {record_name} AND recordset_data.type = {type} | WHERE recordset_data.zone_id = {zone_id} AND recordset.name = {record_name} AND recordset_data.type = {type}
""".stripMargin """.stripMargin
private val FIND_BY_ZONEID_NAME = private val FIND_BY_ZONEID_NAME =
@@ -73,7 +72,7 @@ class MySqlRecordSetDataRepository
|SELECT recordset.data, recordset_data.fqdn |SELECT recordset.data, recordset_data.fqdn
| FROM recordset_data | FROM recordset_data
| INNER JOIN recordset ON recordset.id=recordset_data.recordset_id | INNER JOIN recordset ON recordset.id=recordset_data.recordset_id
| WHERE recordset_data.zone_id = {zone_id} AND recordset_data.record_name = {record_name} | WHERE recordset_data.zone_id = {zone_id} AND recordset.name = {record_name}
""".stripMargin """.stripMargin
@@ -97,7 +96,8 @@ class MySqlRecordSetDataRepository
sql""" sql"""
|SELECT recordset_id |SELECT recordset_id
| FROM recordset_data | FROM recordset_data
|WHERE owner_group_id = {ownerGroupId} | INNER JOIN recordset ON recordset.id=recordset_data.recordset_id
|WHERE recordset.owner_group_id = {ownerGroupId}
|LIMIT 1 |LIMIT 1
""".stripMargin """.stripMargin
@@ -116,13 +116,11 @@ class MySqlRecordSetDataRepository
RsData( RsData(
db, db,
oldRs.id, oldRs.id,
oldRs.records.toString,
oldRs.typ.toString,
oldRs.zoneId, oldRs.zoneId,
oldRs.name,
toFQDN(change.zone.name, oldRs.name), toFQDN(change.zone.name, oldRs.name),
toFQDN(change.zone.name, oldRs.name).reverse, toFQDN(change.zone.name, oldRs.name).reverse,
oldRs.typ.toString,
oldRs.records.toString,
oldRs.ownerGroupId,
"update" "update"
) )
) )
@@ -146,10 +144,8 @@ class MySqlRecordSetDataRepository
i.recordSet.records.toString, i.recordSet.records.toString,
i.recordSet.typ.toString, i.recordSet.typ.toString,
i.recordSet.zoneId, i.recordSet.zoneId,
i.recordSet.name,
toFQDN(i.zone.name, i.recordSet.name), toFQDN(i.zone.name, i.recordSet.name),
toFQDN(i.zone.name, i.recordSet.name).reverse, toFQDN(i.zone.name, i.recordSet.name).reverse,
i.recordSet.ownerGroupId,
"insert" "insert"
)) ))
} }
@@ -161,14 +157,13 @@ class MySqlRecordSetDataRepository
u.recordSet.records.toString, u.recordSet.records.toString,
u.recordSet.typ.toString, u.recordSet.typ.toString,
u.recordSet.zoneId, u.recordSet.zoneId,
u.recordSet.name,
toFQDN(u.zone.name, u.recordSet.name), toFQDN(u.zone.name, u.recordSet.name),
toFQDN(u.zone.name, u.recordSet.name).reverse, toFQDN(u.zone.name, u.recordSet.name).reverse,
u.recordSet.ownerGroupId,
"update" "update"
) )
) )
} }
val deletes: Seq[Seq[Any]] = completeDeletes.map(d => Seq[Any](d.recordSet.id)) val deletes: Seq[Seq[Any]] = completeDeletes.map(d => Seq[Any](d.recordSet.id))
IO { IO {
db.withinTx { implicit session => db.withinTx { implicit session =>
@@ -202,17 +197,15 @@ class MySqlRecordSetDataRepository
recordData: String, recordData: String,
recordType: String, recordType: String,
zoneId: String, zoneId: String,
recordName: String,
FQDN: String, FQDN: String,
reverseFQDN: String, reverseFQDN: String,
ownerGroupId: Option[String],
rs: String rs: String
): Unit = ): Unit =
rs match { rs match {
/** /**
* insert the rsdata, as if recordset are created * insert the rsdata, as if recordset are created
*/ */
case "insert" => rsDataSave(db, recordID, recordData, recordType, zoneId, recordName, FQDN, reverseFQDN, ownerGroupId) case "insert" => rsDataSave(db, recordID, recordData, recordType, zoneId, FQDN, reverseFQDN)
/** /**
* delete and insert the rsdata, as if recordset are updated. * delete and insert the rsdata, as if recordset are updated.
*/ */
@@ -223,7 +216,7 @@ class MySqlRecordSetDataRepository
.update() .update()
.apply() .apply()
} }
rsDataSave(db, recordID, recordData, recordType, zoneId, recordName, FQDN, reverseFQDN, ownerGroupId) rsDataSave(db, recordID, recordData, recordType, zoneId, FQDN, reverseFQDN)
} }
def rsDataSave( def rsDataSave(
@@ -232,28 +225,24 @@ class MySqlRecordSetDataRepository
recordData: String, recordData: String,
recordType: String, recordType: String,
zoneId: String, zoneId: String,
recordName: String,
FQDN: String, FQDN: String,
reverseFQDN: String, reverseFQDN: String,
ownerGroupId: Option[String]
): Unit = { ): Unit = {
recordType match { recordType match {
case "DS" => for (ipString<- recordData.split(Pattern.quote("),")).map(_.trim).toList) { case "DS" => for (ipString<- recordData.split(Pattern.quote("),")).map(_.trim).toList) {
insertRecordSetData(db, recordId, zoneId, recordName, FQDN, reverseFQDN, recordType, ipString, ownerGroupId)} insertRecordSetData(db, recordId, zoneId, FQDN, reverseFQDN, recordType, ipString)}
case _ => for (ipString <- recordData.split(",").map(_.trim).toList) { case _ => for (ipString <- recordData.split(",").map(_.trim).toList) {
insertRecordSetData(db,recordId,zoneId,recordName,FQDN,reverseFQDN,recordType,ipString,ownerGroupId)} insertRecordSetData(db,recordId,zoneId,FQDN,reverseFQDN,recordType,ipString)}
}} }}
def insertRecordSetData( def insertRecordSetData(
db: DB, db: DB,
recordId: String, recordId: String,
zoneId: String, zoneId: String,
recordName: String,
FQDN: String, FQDN: String,
reverseFQDN: String, reverseFQDN: String,
recordType: String, recordType: String,
ipString: String, ipString: String,
ownerGroupId: Option[String]
): Unit = { ): Unit = {
var parseIp: String = null var parseIp: String = null
var records: String = null var records: String = null
@@ -271,13 +260,11 @@ class MySqlRecordSetDataRepository
.bindByName( .bindByName(
'recordset_id -> recordId, 'recordset_id -> recordId,
'zone_id -> zoneId, 'zone_id -> zoneId,
'record_name -> recordName,
'fqdn -> FQDN, 'fqdn -> FQDN,
'reverse_fqdn -> reverseFQDN, 'reverse_fqdn -> reverseFQDN,
'type -> recordType, 'type -> recordType,
'record_data -> records, 'record_data -> records,
'ip -> parseIp, 'ip -> parseIp
'owner_group_id -> ownerGroupId
) )
.update() .update()
.apply() .apply()
@@ -461,7 +448,7 @@ class MySqlRecordSetDataRepository
// setup optional filters // setup optional filters
val zoneAndNameFilters = (zoneId, recordNameFilter) match { val zoneAndNameFilters = (zoneId, recordNameFilter) match {
case (Some(zId), Some(rName)) => case (Some(zId), Some(rName)) =>
Some(sqls"recordset_data.zone_id = $zId AND recordset_data.record_name LIKE ${rName.replace('*', '%')} ") Some(sqls"recordset_data.zone_id = $zId AND recordset.name LIKE ${rName.replace('*', '%')} ")
case (None, Some(fqdn)) => val reversefqdn = fqdn.reverse // reverse the fqdn. case (None, Some(fqdn)) => val reversefqdn = fqdn.reverse // reverse the fqdn.
Some(sqls"recordset_data.reverse_fqdn LIKE ${reversefqdn.replace('*', '%')} ") Some(sqls"recordset_data.reverse_fqdn LIKE ${reversefqdn.replace('*', '%')} ")
case (Some(zId), None) => Some(sqls"recordset_data.zone_id = $zId ") case (Some(zId), None) => Some(sqls"recordset_data.zone_id = $zId ")
@@ -475,38 +462,38 @@ class MySqlRecordSetDataRepository
val sortBy = (searchByZone, nameSort) match { val sortBy = (searchByZone, nameSort) match {
case (true, NameSort.DESC) => case (true, NameSort.DESC) =>
pagingKey.as( pagingKey.as(
sqls"((recordset_data.record_name <= ${pagingKey.map(pk => pk.recordName)} AND recordset_data.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.record_name < ${pagingKey.map(pk => pk.recordName)})" sqls"((recordset.name <= ${pagingKey.map(pk => pk.recordName)} AND recordset.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset.name < ${pagingKey.map(pk => pk.recordName)})"
) )
case (false, NameSort.ASC) => case (false, NameSort.ASC) =>
pagingKey.as( pagingKey.as(
sqls"((recordset_data.fqdn >= ${pagingKey.map(pk => pk.recordName)} AND recordset_data.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.fqdn > ${pagingKey.map(pk => pk.recordName)})" sqls"((recordset_data.fqdn >= ${pagingKey.map(pk => pk.recordName)} AND recordset.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.fqdn > ${pagingKey.map(pk => pk.recordName)})"
) )
case (false, NameSort.DESC) => case (false, NameSort.DESC) =>
pagingKey.as( pagingKey.as(
sqls"((recordset_data.fqdn <= ${pagingKey.map(pk => pk.recordName)} AND recordset_data.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.fqdn < ${pagingKey.map(pk => pk.recordName)})" sqls"((recordset_data.fqdn <= ${pagingKey.map(pk => pk.recordName)} AND recordset.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.fqdn < ${pagingKey.map(pk => pk.recordName)})"
) )
case _ => case _ =>
pagingKey.as( pagingKey.as(
sqls"((recordset_data.record_name >= ${pagingKey.map(pk => pk.recordName)} AND recordset_data.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset_data.record_name > ${pagingKey.map(pk => pk.recordName)})" sqls"((recordset.name >= ${pagingKey.map(pk => pk.recordName)} AND recordset.type > ${pagingKey.map(pk => pk.recordType)}) OR recordset.name > ${pagingKey.map(pk => pk.recordName)})"
) )
} }
val typeFilter = recordTypeFilter.map { t => val typeFilter = recordTypeFilter.map { t =>
val list = t.map(fromRecordType) val list = t.map(fromRecordType)
sqls"recordset_data.type IN ($list)" sqls"recordset.type IN ($list)"
} }
val ownerGroupFilter = val ownerGroupFilter =
recordOwnerGroupFilter.map(owner => sqls"recordset_data.owner_group_id = $owner ") recordOwnerGroupFilter.map(owner => sqls"recordset.owner_group_id = $owner ")
val opts = val opts =
(zoneAndNameFilters ++ sortBy ++ typeFilter ++ ownerGroupFilter).toList (zoneAndNameFilters ++ sortBy ++ typeFilter ++ ownerGroupFilter).toList
val qualifiers = if (nameSort == ASC) { val qualifiers = if (nameSort == ASC) {
sqls"ORDER BY recordset_data.fqdn ASC, recordset_data.type ASC " sqls"ORDER BY recordset_data.fqdn ASC, recordset.type ASC "
} }
else { else {
sqls"ORDER BY recordset_data.fqdn DESC, recordset_data.type ASC " sqls"ORDER BY recordset_data.fqdn DESC, recordset.type ASC "
} }
val recordLimit = maxPlusOne match { val recordLimit = maxPlusOne match {