public TableConstraint( string identifier, DatabaseKeyType keyType, string constraintName, IEnumerable <string> columnNames, IEnumerable <string> columnTypes ) { if (identifier.IsNullOrWhiteSpace()) { throw new ArgumentNullException(nameof(identifier)); } Identifier = identifier; if (!keyType.IsValid()) { throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType)); } KeyTitle = _keyTypeTitles[keyType]; KeyType = keyType; ConstraintName = constraintName ?? string.Empty; ColumnNames = columnNames?.ToList() ?? throw new ArgumentNullException(nameof(columnNames)); ColumnTypes = columnTypes?.ToList() ?? throw new ArgumentNullException(nameof(columnTypes)); }
public static void Ctor_GivenNullColumnSet_ThrowsArgumentNullException() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Primary; Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, null), Throws.ArgumentNullException); }
public static void Ctor_GivenNullName_DoesNotThrowArgumentNullException() { const DatabaseKeyType keyType = DatabaseKeyType.Primary; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; Assert.That(() => new DatabaseKey(null, keyType, columns, true), Throws.Nothing); }
public static void Ctor_GivenInvalidKeyType_ThrowsArgumentException() { const DatabaseKeyType badKeyType = (DatabaseKeyType)55; Assert.That(() => new FakeKey(new List <IModelledColumn> { Mock.Of <IModelledColumn>() }, badKeyType), Throws.ArgumentException); }
public static void Ctor_GivenEmptyColumnSet_ThrowsArgumentNullException() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Primary; var columns = Array.Empty <IDatabaseColumn>(); Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentNullException); }
public static void Ctor_GivenColumnSetContainingNullColumn_ThrowsArgumentNullException() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Primary; var columns = new IDatabaseColumn[] { null }; Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentNullException); }
public static void Ctor_GivenNullColumnSet_ThrowsArgumentNullException() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Primary; const bool enabled = true; Assert.That(() => new OracleDatabaseKey(keyName, keyType, null, enabled), Throws.ArgumentNullException); }
public static void Ctor_GivenNullName_ThrowsArgumentNullException() { const DatabaseKeyType keyType = DatabaseKeyType.Primary; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; Assert.That(() => new PostgreSqlDatabaseKey(null, keyType, columns), Throws.ArgumentNullException); }
public static void Ctor_GivenInvalidDatabaseKeyType_ThrowsArgumentException() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = (DatabaseKeyType)55; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentException); }
public static void Ctor_GivenNullName_ThrowsArgumentNullException() { const DatabaseKeyType keyType = DatabaseKeyType.Primary; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; const bool enabled = true; Assert.That(() => new OracleDatabaseKey(null, keyType, columns, enabled), Throws.ArgumentNullException); }
public static void ToString_WhenInvoked_ReturnsExpectedValues(DatabaseKeyType keyType, string name, string expectedResult) { var keyName = Identifier.CreateQualifiedIdentifier(name); var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; var key = new PostgreSqlDatabaseKey(keyName, keyType, columns); var result = key.ToString(); Assert.That(result, Is.EqualTo(expectedResult)); }
public static void IsEnabled_GivenRegularObject_ReturnsTrue() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; var key = new PostgreSqlDatabaseKey(keyName, keyType, columns); Assert.That(key.IsEnabled, Is.True); }
public static void Name_PropertyGet_EqualsCtorArg() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Primary; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; var key = new PostgreSqlDatabaseKey(keyName, keyType, columns); Assert.That(key.Name.UnwrapSome(), Is.EqualTo(keyName)); }
public static void Columns_PropertyGet_EqualsCtorArg() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; var key = new PostgreSqlDatabaseKey(keyName, keyType, columns); Assert.That(key.Columns, Is.EqualTo(columns)); }
public static void IsEnabled_WhenGivenFalseInCtor_ReturnsFalse() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; const bool enabled = false; var key = new DatabaseKey(keyName, keyType, columns, enabled); Assert.That(key.IsEnabled, Is.EqualTo(enabled)); }
public static void IsEnabled_PropertyGet_ReturnsTrue() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; const bool enabled = true; var key = new SqliteDatabaseKey(keyName, keyType, columns); Assert.That(key.IsEnabled, Is.EqualTo(enabled)); }
public static void KeyType_PropertyGet_EqualsCtorArg() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; const bool enabled = true; var key = new OracleDatabaseKey(keyName, keyType, columns, enabled); Assert.That(key.KeyType, Is.EqualTo(keyType)); }
public static void IsEnabled_GivenFalseCtorArgAndPropertyGet_EqualsCtorArg() { Identifier keyName = "test_key"; const DatabaseKeyType keyType = DatabaseKeyType.Foreign; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; const bool enabled = false; var key = new SqlServerDatabaseKey(keyName, keyType, columns, enabled); Assert.That(key.IsEnabled, Is.EqualTo(enabled)); }
public static void ToString_WhenInvoked_ReturnsExpectedValues(DatabaseKeyType keyType, string name, string expectedResult) { var keyName = !name.IsNullOrWhiteSpace() ? Option <Identifier> .Some(Identifier.CreateQualifiedIdentifier(name)) : Option <Identifier> .None; var column = Mock.Of <IDatabaseColumn>(); var columns = new[] { column }; var key = new SqliteDatabaseKey(keyName, keyType, columns); var result = key.ToString(); Assert.That(result, Is.EqualTo(expectedResult)); }
protected Key(IEnumerable <IModelledColumn> columns, DatabaseKeyType keyType) { if (columns == null || columns.Empty() || columns.AnyNull()) { throw new ArgumentNullException(nameof(columns)); } if (!keyType.IsValid()) { throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType)); } Columns = columns; KeyType = keyType; }
/// <summary> /// Initializes a new instance of the <see cref="SqliteDatabaseKey"/> class. /// </summary> /// <param name="name">The constraint name, if available.</param> /// <param name="keyType">Type of the key constraint.</param> /// <param name="columns">A collection of table columns.</param> /// <exception cref="ArgumentNullException"><paramref name="name"/> or <paramref name="columns"/> is <c>null</c>. Alternatively, if <paramref name="columns"/> is empty or has <c>null</c> values.</exception> /// <exception cref="ArgumentException"><paramref name="keyType"/> is not a valid enum.</exception> public SqliteDatabaseKey(Option <Identifier> name, DatabaseKeyType keyType, IEnumerable <IDatabaseColumn> columns) { if (columns == null || columns.Empty() || columns.AnyNull()) { throw new ArgumentNullException(nameof(columns)); } if (!keyType.IsValid()) { throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType)); } Name = name.Map(n => Identifier.CreateQualifiedIdentifier(n.LocalName)); KeyType = keyType; Columns = columns.ToList(); }
/// <summary> /// Initializes a new instance of the <see cref="DatabaseKey"/> class. /// </summary> /// <param name="name">A constraint name, if available.</param> /// <param name="keyType">The key constraint type.</param> /// <param name="columns">The columns covered by the key.</param> /// <param name="isEnabled">Whether the constraint is enabled.</param> /// <exception cref="ArgumentNullException"><paramref name="columns"/> is <c>null</c> or contains <c>null</c> values.</exception> /// <exception cref="ArgumentException"><paramref name="keyType"/> is an invalid enum value.</exception> public DatabaseKey(Option <Identifier> name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns, bool isEnabled) { if (columns == null || columns.Empty() || columns.AnyNull()) { throw new ArgumentNullException(nameof(columns)); } if (!keyType.IsValid()) { throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType)); } Name = name.Map(n => Identifier.CreateQualifiedIdentifier(n.LocalName)); // strip to localname only KeyType = keyType; Columns = columns; IsEnabled = isEnabled; }
/// <summary> /// Initializes a new instance of the <see cref="PostgreSqlDatabaseKey"/> class. /// </summary> /// <param name="name">The key constraint name.</param> /// <param name="keyType">Type of the key constraint.</param> /// <param name="columns">A collection of table columns.</param> /// <exception cref="ArgumentNullException"><paramref name="name"/> or <paramref name="columns"/> is <c>null</c>. Alternatively, if <paramref name="columns"/> is empty or has <c>null</c> values.</exception> /// <exception cref="ArgumentException"><paramref name="keyType"/> is not a valid enum.</exception> public PostgreSqlDatabaseKey(Identifier name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (columns == null || columns.Empty() || columns.AnyNull()) { throw new ArgumentNullException(nameof(columns)); } if (!keyType.IsValid()) { throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType)); } Name = Option <Identifier> .Some(name.LocalName); KeyType = keyType; Columns = columns; }
public ReflectionKey(Identifier name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns) : base(name, keyType, columns, true) // TODO: should we ever allow disabled keys? { }
public FakeKey(IEnumerable <IModelledColumn> columns, DatabaseKeyType keyType) : base(columns, keyType) { }
public Key(string name, DatabaseKeyType keyType) : this(name) { this.keytype = keyType; }