func NewSQLDB(
db *sql.DB,
convergenceWorkersSize int,
updateWorkersSize int,
serializationFormat *format.Format,
cryptor encryption.Cryptor,
guidProvider guidprovider.GUIDProvider,
clock clock.Clock,
flavor string,
) *SQLDB {
return &SQLDB{
db: db,
convergenceWorkersSize: convergenceWorkersSize,
updateWorkersSize: updateWorkersSize,
clock: clock,
format: serializationFormat,
guidProvider: guidProvider,
serializer: format.NewSerializer(cryptor),
cryptor: cryptor,
encoder: format.NewEncoder(cryptor),
flavor: flavor,
}
}
BeforeEach(func() {
task = model_helpers.NewValidTask("a-guid")
logger = lagertest.NewTestLogger("test")
cryptor = &encryptionfakes.FakeCryptor{}
cryptor.EncryptStub = func(plaintext []byte) (encryption.Encrypted, error) {
nonce := [12]byte{}
return encryption.Encrypted{
KeyLabel: "label",
Nonce: nonce[:],
CipherText: plaintext,
}, nil
}
cryptor.DecryptStub = func(ciphered encryption.Encrypted) ([]byte, error) {
return ciphered.CipherText, nil
}
encoder = format.NewEncoder(cryptor)
serializer = format.NewSerializer(cryptor)
})
Describe("Marshal", func() {
Describe("LEGACY_FORMATTING", func() {
It("marshals the data as-is without an envelope", func() {
jsonEncodedTask, err := json.Marshal(task)
Expect(err).NotTo(HaveOccurred())
encoded, err := serializer.Marshal(logger, format.LEGACY_FORMATTING, task)
Expect(err).NotTo(HaveOccurred())
Expect(encoded).To(MatchJSON(jsonEncodedTask))
})
})
Expect(domains).To(HaveKey("domain-1"))
Expect(domains).To(HaveKeyWithValue("domain-1",
BeNumerically(">", fakeClock.Now().Add(time.Second*95).UnixNano())))
Expect(domains).To(HaveKeyWithValue("domain-2",
BeNumerically(">", fakeClock.Now().Add(time.Second*95).UnixNano())))
})
})
Describe("Desired LRPs", func() {
var (
existingDesiredLRPs []migrations.ETCDToSQLDesiredLRP
desiredLRPsToCreate int
)
BeforeEach(func() {
encoder := format.NewEncoder(cryptor)
desiredLRPsToCreate = 3
for i := 0; i < desiredLRPsToCreate; i++ {
processGuid := fmt.Sprintf("process-guid-%d", i)
var desiredLRP *models.DesiredLRP
desiredLRP = model_helpers.NewValidDesiredLRP(processGuid)
schedulingInfo, runInfo := desiredLRP.CreateComponents(fakeClock.Now())
var (
encryptedVolumePlacement []byte
err error
)
if i == 0 { // test for nil and full VolumePlacements
schedulingInfo.VolumePlacement = nil
func (e *EncryptRoutes) SetCryptor(cryptor encryption.Cryptor) {
e.encoder = format.NewEncoder(cryptor)
}
