public static void Constructor___Should_succeed___If_description_has_underscores()
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
"some_under_scores",
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
result.MustForTest().NotBeNull();
}
static BackupSqlServerDatabaseDetailsTest()
{
ConstructorArgumentValidationTestScenarios
.RemoveAllScenarios()
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentException when parameter 'name' has invalid chars scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
"not-valid",
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"name",
"not alphanumeric",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentException when parameter 'name' is longer than 128 chars scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
new string('a', 129),
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"Name",
"128 characters",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentException when parameter 'description' is longer than 255 chars scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
new string('a', 256),
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"Description",
"255 characters",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentException when parameter 'description' has invalid chars scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
"not-valid",
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"description",
"not alphanumeric",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentNullException when parameter 'backupTo' is null scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
null,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentNullException),
ExpectedExceptionMessageContains = new[]
{
"backupTo",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "constructor should throw ArgumentNullException when parameter 'credential' is null and Device is 'Url' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
Device.Url,
referenceObject.BackupTo,
null,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentNullException),
ExpectedExceptionMessageContains = new[]
{
"credential",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'credential' is white space and Device is 'Url' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
Device.Url,
referenceObject.BackupTo,
Invariant($" {Environment.NewLine} "),
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"credential",
"white space",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'credential' is not-alphanumeric and Device is 'Url' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
Device.Url,
referenceObject.BackupTo,
Invariant($"not-alpha-numeric"),
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"credential",
"alphanumeric",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'errorHandling' is 'None' and ChecksumOption is 'Checksum' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
Device.Url,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
ChecksumOption.Checksum,
ErrorHandling.None,
referenceObject.Cipher,
referenceObject.Encryptor,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"ErrorHandling cannot be None when using checksum.",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'encryptor' is 'None' and Cipher is not 'NoEncryption' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var cipher = A.Dummy <Cipher>().ThatIsNot(Cipher.NoEncryption);
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
cipher,
Encryptor.None,
referenceObject.EncryptorName);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"Encryptor is required when any Cipher != NoEncryption",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'encryptorName' is 'null' and Cipher is not 'NoEncryption' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var cipher = A.Dummy <Cipher>().ThatIsNot(Cipher.NoEncryption);
var encryptor = A.Dummy <Encryptor>().ThatIsNot(Encryptor.None);
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
cipher,
encryptor,
null);
return(result);
},
ExpectedExceptionType = typeof(ArgumentNullException),
ExpectedExceptionMessageContains = new[]
{
"encryptorName",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'encryptorName' is 'empty string' and Cipher is not 'NoEncryption' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var cipher = A.Dummy <Cipher>().ThatIsNot(Cipher.NoEncryption);
var encryptor = A.Dummy <Encryptor>().ThatIsNot(Encryptor.None);
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
cipher,
encryptor,
string.Empty);
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"encryptorName",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'encryptorName' is 'whitespace' and Cipher is not 'NoEncryption' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var cipher = A.Dummy <Cipher>().ThatIsNot(Cipher.NoEncryption);
var encryptor = A.Dummy <Encryptor>().ThatIsNot(Encryptor.None);
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
cipher,
encryptor,
Invariant($" {Environment.NewLine} "));
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"encryptorName",
},
})
.AddScenario(
() =>
new ConstructorArgumentValidationTestScenario <BackupSqlServerDatabaseDetails>
{
Name =
"constructor should throw ArgumentException when parameter 'encryptorName' is 'invalid' and Cipher is not 'NoEncryption' scenario",
ConstructionFunc = () =>
{
var referenceObject = A.Dummy <BackupSqlServerDatabaseDetails>();
var cipher = A.Dummy <Cipher>().ThatIsNot(Cipher.NoEncryption);
var encryptor = A.Dummy <Encryptor>().ThatIsNot(Encryptor.None);
var result = new BackupSqlServerDatabaseDetails(
referenceObject.Name,
referenceObject.Description,
referenceObject.Device,
referenceObject.BackupTo,
referenceObject.Credential,
referenceObject.CompressionOption,
referenceObject.ChecksumOption,
referenceObject.ErrorHandling,
cipher,
encryptor,
Invariant($"not-valid"));
return(result);
},
ExpectedExceptionType = typeof(ArgumentException),
ExpectedExceptionMessageContains = new[]
{
"encryptorName",
},
});
EquatableTestScenarios
.RemoveAllScenarios()
.AddScenario(() =>
new EquatableTestScenario <BackupSqlServerDatabaseDetails>
{
Name = "Default Code Generated Scenario",
ReferenceObject = ReferenceObjectForEquatableTestScenarios,
ObjectsThatAreEqualToButNotTheSameAsReferenceObject = new BackupSqlServerDatabaseDetails[]
{
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
},
ObjectsThatAreNotEqualToReferenceObject = new BackupSqlServerDatabaseDetails[]
{
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.BackupTo.IsEqualTo(ReferenceObjectForEquatableTestScenarios.BackupTo)).BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.ChecksumOption.IsEqualTo(ReferenceObjectForEquatableTestScenarios.ChecksumOption)).ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.CompressionOption.IsEqualTo(ReferenceObjectForEquatableTestScenarios.CompressionOption)).CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.Credential.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Credential)).Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.Description.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Description)).Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.Device.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Device)).Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
new BackupSqlServerDatabaseDetails(
ReferenceObjectForEquatableTestScenarios.Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.EncryptorName.IsEqualTo(ReferenceObjectForEquatableTestScenarios.EncryptorName)).EncryptorName),
new BackupSqlServerDatabaseDetails(
A.Dummy <BackupSqlServerDatabaseDetails>().Whose(_ => !_.Name.IsEqualTo(ReferenceObjectForEquatableTestScenarios.Name)).Name,
ReferenceObjectForEquatableTestScenarios.Description,
ReferenceObjectForEquatableTestScenarios.Device,
ReferenceObjectForEquatableTestScenarios.BackupTo,
ReferenceObjectForEquatableTestScenarios.Credential,
ReferenceObjectForEquatableTestScenarios.CompressionOption,
ReferenceObjectForEquatableTestScenarios.ChecksumOption,
ReferenceObjectForEquatableTestScenarios.ErrorHandling,
ReferenceObjectForEquatableTestScenarios.Cipher,
ReferenceObjectForEquatableTestScenarios.Encryptor,
ReferenceObjectForEquatableTestScenarios.EncryptorName),
},
ObjectsThatAreNotOfTheSameTypeAsReferenceObject = new object[]
{
A.Dummy <object>(),
A.Dummy <string>(),
A.Dummy <int>(),
A.Dummy <int?>(),
A.Dummy <Guid>(),
},
});
}
public SqlServerDummyFactory()
{
// --------------------------- Enums -----------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ScriptableObjectType.Invalid);
// --------------------------- Interfaces ------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
(ISqlOutputParameterResult) new SqlOutputParameterResult <int?>(A.Dummy <OutputParameterDefinition <int?> >(), A.Dummy <int?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
(IResourceLocator)A.Dummy <SqlServerLocator>());
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
(IDatabaseDefinition)A.Dummy <SqlServerDatabaseDefinition>());
// --------------------------- Data Type Representation -----------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var supportedLength = A.Dummy <PositiveInteger>().ThatIs(_ => (_ >= 1) && (_ <= BinarySqlDataTypeRepresentation.MaxLengthConstant));
var result = new BinarySqlDataTypeRepresentation(supportedLength);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var precision = A.Dummy <byte>().ThatIs(_ => (_ >= 1) && (_ <= 38));
var scale = A.Dummy <byte>().ThatIs(_ => (_ <= precision));
var result = new DecimalSqlDataTypeRepresentation(precision, scale);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var supportUnicode = A.Dummy <bool>();
var supportedLength = supportUnicode
? A.Dummy <PositiveInteger>().ThatIs(_ => (_ >= 1) && (_ <= StringSqlDataTypeRepresentation.MaxUnicodeLengthConstant))
: A.Dummy <PositiveInteger>().ThatIs(_ => (_ >= 1) && (_ <= StringSqlDataTypeRepresentation.MaxNonUnicodeLengthConstant));
var result = new StringSqlDataTypeRepresentation(supportUnicode, supportedLength);
return(result);
});
// ------------------------ Definition ---------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => ThreadSafeRandom.Next(0, 2) == 0
? (ParameterDefinitionBase)A.Dummy <InputParameterDefinition <int?> >()
: A.Dummy <OutputParameterDefinition <int?> >());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => (InputParameterDefinitionBase)A.Dummy <InputParameterDefinition <int?> >());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => (OutputParameterDefinitionBase)A.Dummy <OutputParameterDefinition <int?> >());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new InputParameterDefinition <int?>(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <IntSqlDataTypeRepresentation>(),
A.Dummy <int?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new OutputParameterDefinition <int?>(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <IntSqlDataTypeRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ColumnDefinition(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <SqlDataTypeRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SqlServerDatabaseDefinition(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <DatabaseType>(),
A.Dummy <RecoveryMode>(),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <long>(),
A.Dummy <long>(),
A.Dummy <long>(),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <long>(),
A.Dummy <long>(),
A.Dummy <long>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TableDefinition(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <IReadOnlyList <ColumnDefinition> >()));
// ------------------------ Management ---------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var checksumOption = A.Dummy <ChecksumOption>();
var cipher = A.Dummy <Cipher>();
var compressionOption = A.Dummy <CompressionOption>();
var device = A.Dummy <Device>();
var encryptor = A.Dummy <Encryptor>();
var errorHandling = A.Dummy <ErrorHandling>();
if (cipher == Cipher.NoEncryption && encryptor != Encryptor.None)
{
encryptor = Encryptor.None;
}
if (cipher != Cipher.NoEncryption && encryptor == Encryptor.None)
{
encryptor = A.Dummy <Encryptor>().ThatIsNot(Encryptor.None);
}
if (checksumOption == ChecksumOption.Checksum && errorHandling == ErrorHandling.None)
{
errorHandling = A.Dummy <ErrorHandling>().ThatIsNot(ErrorHandling.None);
}
var backupSqlServerDatabaseDetails = new BackupSqlServerDatabaseDetails(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <string>().Replace("-", string.Empty),
device,
A.Dummy <Uri>(),
A.Dummy <string>().Replace("-", string.Empty),
compressionOption,
checksumOption,
errorHandling,
cipher,
encryptor,
A.Dummy <string>().Replace("-", string.Empty));
return(backupSqlServerDatabaseDetails);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var checksumOption = A.Dummy <ChecksumOption>();
var device = A.Dummy <Device>();
var recoveryOption = A.Dummy <RecoveryOption>();
var replaceOption = A.Dummy <ReplaceOption>();
var restrictedUserOption = A.Dummy <RestrictedUserOption>();
var errorHandling = A.Dummy <ErrorHandling>();
if (checksumOption == ChecksumOption.Checksum && errorHandling == ErrorHandling.None)
{
errorHandling = A.Dummy <ErrorHandling>().ThatIsNot(ErrorHandling.None);
}
var logFilePath = FormattableString.Invariant($"C:\\directory\\{A.Dummy<string>()}.dat");
var dataFilePath = FormattableString.Invariant($"C:\\directory\\{A.Dummy<string>()}.ldf");
return(new RestoreSqlServerDatabaseDetails(
dataFilePath,
logFilePath,
device,
A.Dummy <Uri>(),
A.Dummy <string>().Replace("-", string.Empty),
checksumOption,
errorHandling,
recoveryOption,
replaceOption,
restrictedUserOption));
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TableDescription(
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <string>().Replace("-", string.Empty),
A.Dummy <IReadOnlyCollection <ColumnDescription> >()));
// ------------------------ Resource Location ---------------------------------
// ------------------------ Stream ---------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SqlOutputParameterResult <int?>(
A.Dummy <OutputParameterDefinition <int?> >(),
A.Dummy <int?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SqlServerStreamConfig(
A.Dummy <string>(),
A.Dummy <StreamAccessKinds>().Whose(_ => _ != StreamAccessKinds.None),
TimeSpan.FromSeconds(A.Dummy <PositiveDouble>()),
TimeSpan.FromSeconds(A.Dummy <PositiveDouble>()),
A.Dummy <SerializerRepresentation>(),
A.Dummy <SerializationFormat>(),
Some.ReadOnlyDummies <SqlServerLocator>().ToList()));
// ------------------------ Operations ---------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CreateStreamUserOp(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
CreateStreamUserOp.SupportedStreamAccessKinds.Take(ThreadSafeRandom.Next(1, CreateStreamUserOp.SupportedStreamAccessKinds.Count + 1)).Single(),
A.Dummy <bool>())
);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DeleteDatabaseOp(
A.Dummy <string>().Replace("-", string.Empty)));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UpdateStreamStoredProceduresOp(A.Dummy <RecordTagAssociationManagementStrategy>(), A.Dummy <PositiveInteger>()));
}
