public void ShouldBeInvalidDistrictOrEdOrgId(int invalidId)
        {
            var invalidInstanceName = invalidId.ToString();

            using (var connection1 = GetDatabaseConnection(invalidInstanceName, _dbNamePrefix))
                using (var connection2 = GetDatabaseConnection(invalidInstanceName, _dbNamePrefix))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(invalidId, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = invalidId,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, _databaseValidationService.Object).ShouldNotValidate(newInstance,
                                                                                                                                                      "'ODS Instance District / EdOrg Id' must be a valid positive integer.");
                    });
                }
        }
        public void ShouldNotRegisterInstanceIfOdsInstanceIdentifierAssociatedDbDoesNotExistsOnDistrictSpecificMode()
        {
            const int    odsInstanceNumericSuffix = 8787877;
            const string instanceName             = "8787877";

            var mockDatabaseValidationService = new Mock <IDatabaseValidationService>();

            mockDatabaseValidationService.Setup(x => x.IsValidDatabase(odsInstanceNumericSuffix, ApiMode.DistrictSpecific))
            .Returns(false);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider.SetupSequence(
                        x => x.CreateNewConnection(odsInstanceNumericSuffix, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = odsInstanceNumericSuffix,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, mockDatabaseValidationService.Object)
                        .ShouldNotValidate(newInstance,
                                           "Could not connect to an ODS instance database for this Education Organization / District Id.");
                    });
                }
        }
Beispiel #3
0
        public void ShouldValidateValidInstanceOnDistrictSpecificMode()
        {
            ResetOdsInstanceRegistrations();

            var instanceName = "TestInstance_7878787";

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(7878787, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 7878787,
                        Description   = Sample("Description")
                    };

                    new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                    .ShouldValidate(newInstance);
                }
        }
Beispiel #4
0
        public void ShouldNotRegisterInstanceIfOdsInstanceIdentifierAssociatedDbDoesNotExistsOnYearSpecificMode()
        {
            const int    odsInstanceNumericSuffix = 2020;
            const string instanceName             = "Test_Ods_2020";

            var mockDatabaseValidationService = new Mock <IDatabaseValidationService>();

            mockDatabaseValidationService.Setup(x => x.IsValidDatabase(odsInstanceNumericSuffix, ApiMode.YearSpecific))
            .Returns(false);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider.SetupSequence(
                        x => x.CreateNewConnection(odsInstanceNumericSuffix, ApiMode.YearSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);
                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = odsInstanceNumericSuffix,
                        Description   = Sample("Description")
                    };

                    new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, mockDatabaseValidationService.Object, _connectionProvider.Object)
                    .ShouldNotValidate(newInstance,
                                       "Could not connect to an ODS instance database for this school year.");
                }
        }
Beispiel #5
0
        public void ShouldNotRegisterInstanceIfOdsInstanceNameNotWithinApplicationNameMaxLength()
        {
            ResetOdsInstanceRegistrations();

            var instanceName = "Test_Ods_7878787";
            var prefix       = Sample("TestPrefix_", 50);

            using (var connection1 = GetDatabaseConnection(instanceName, prefix))
                using (var connection2 = GetDatabaseConnection(instanceName, prefix))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(7878787, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 7878787,
                        Description   = Sample("Description")
                    };

                    new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                    .ShouldNotValidate(newInstance, $"The resulting database name {connection1.Database} would be too long for Admin App to set up necessary Application records. Consider shortening the naming convention prefix in the database names and corresponding Web.config entries by 33 characters.");
                }
        }
        public void ShouldReturnValidationMessageWithYear()
        {
            const int    odsInstanceNumericSuffix = 2020;
            const string instanceName             = "2020";

            var mockDatabaseValidationService = new Mock <IDatabaseValidationService>();

            mockDatabaseValidationService.Setup(x => x.IsValidDatabase(odsInstanceNumericSuffix, ApiMode.YearSpecific))
            .Returns(false);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider.SetupSequence(
                        x => x.CreateNewConnection(odsInstanceNumericSuffix, ApiMode.YearSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);
                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = odsInstanceNumericSuffix,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, mockDatabaseValidationService.Object, true)
                        .ShouldNotValidate(newInstance,
                                           $"Could not connect to an ODS instance database for this school year ({odsInstanceNumericSuffix}).");
                    });
                }
        }
Beispiel #7
0
        public void ShouldNotRegisterInstanceIfOdsInstanceIdentifierNotUniqueOnDistrictSpecificMode()
        {
            var instanceName = "Test_Ods_8787877";

            ResetOdsInstanceRegistrations();
            SetupOdsInstanceRegistration(instanceName);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(8787877, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 8787877,
                        Description   = Sample("Description")
                    };

                    new RegisterOdsInstanceModelValidator(
                        SetupContext, _apiModeProvider.Object, _databaseValidationService.Object,
                        _connectionProvider.Object)
                    .ShouldNotValidate(
                        newInstance,
                        "An instance for this Education Organization / District Id already exists.");
                }
        }
        public void ShouldReturnValidationMessageWithDistrictId()
        {
            var instanceName = "8787877";

            ResetOdsInstanceRegistrations();
            SetupOdsInstanceRegistration(instanceName);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(8787877, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 8787877,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(
                            database, _apiModeProvider.Object, _databaseValidationService.Object, true)
                        .ShouldNotValidate(
                            newInstance,
                            "An instance for this Education Organization / District Id (8787877) already exists.");
                    });
                }
        }
Beispiel #9
0
        public void ShouldNotRegisterInstanceIfOdsInstanceIdentifierNotUniqueOnYearSpecificMode()
        {
            var instanceName = "Test_Ods_2020";

            ResetOdsInstanceRegistrations();
            SetupOdsInstanceRegistration(instanceName);
            _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider.SetupSequence(x => x.CreateNewConnection(2020, ApiMode.YearSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 2020,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                        .ShouldNotValidate(newInstance,
                                           "An instance for this school year already exists.");
                    });
                }
        }
        public void ShouldReturnValidationMessageWithDistrictIdAndDescription()
        {
            var districtId   = "8787877";
            var instanceName = "8787877";

            ResetOdsInstanceRegistrations();
            var createdInstance = SetupOdsInstanceRegistration(instanceName);

            using (var connection1 = GetDatabaseConnection(districtId))
                using (var connection2 = GetDatabaseConnection(districtId))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(It.IsAny <int>(), ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 8787878,
                        Description   = createdInstance.Description
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(
                            database, _apiModeProvider.Object, _databaseValidationService.Object, true)
                        .ShouldNotValidate(newInstance,
                                           $"An instance with this description (Education Organization / District Id: 8787878, Description: {newInstance.Description}) already exists.");
                    });
                }
        }
        public void ShouldNotRegisterInstanceIfOdsInstanceDescriptionNotUnique()
        {
            ResetOdsInstanceRegistrations();
            var instance = SetupOdsInstanceRegistration("8787877");

            var instanceName = "7878787";

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider
                    .SetupSequence(x => x.CreateNewConnection(7878787, ApiMode.DistrictSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 7878787,
                        Description   = instance.Description
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, _databaseValidationService.Object)
                        .ShouldNotValidate(newInstance, "An instance with this description already exists.");
                    });
                }
        }
        public void ShouldValidateValidInstanceOnYearSpecificMode()
        {
            ResetOdsInstanceRegistrations();

            var instanceName = "2020";

            using (var connection1 = GetDatabaseConnection(instanceName))
                using (var connection2 = GetDatabaseConnection(instanceName))
                {
                    _connectionProvider.SetupSequence(x => x.CreateNewConnection(2020, ApiMode.YearSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);

                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = 2020,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, _databaseValidationService.Object)
                        .ShouldValidate(newInstance);
                    });
                }
        }
        public void ShouldBeInvalidSchoolYear(int?invalidSchoolYear)
        {
            var invalidInstanceName = invalidSchoolYear.ToString();

            using (var connection1 = GetDatabaseConnection(invalidInstanceName, _dbNamePrefix))
                using (var connection2 = GetDatabaseConnection(invalidInstanceName, _dbNamePrefix))
                {
                    _connectionProvider.SetupSequence(
                        x => x.CreateNewConnection(invalidSchoolYear ?? 0, ApiMode.YearSpecific))
                    .Returns(connection1)
                    .Returns(connection2);

                    _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);
                    var newInstance = new RegisterOdsInstanceModel
                    {
                        NumericSuffix = invalidSchoolYear,
                        Description   = Sample("Description")
                    };

                    Scoped <AdminAppDbContext>(database =>
                    {
                        new RegisterOdsInstanceModelValidator(database, _apiModeProvider.Object, _databaseValidationService.Object)
                        .ShouldNotValidate(newInstance,
                                           invalidSchoolYear == null
                            ? "'ODS Instance School Year' must not be empty."
                            : "'ODS Instance School Year' must be between 1900 and 2099.");
                    });
                }
        }
Beispiel #14
0
        public async Task ShouldRegisterOdsInstance()
        {
            ResetOdsInstanceRegistrations();
            var          instanceName = "TestInstance_23456";
            const string description  = "Test Description";
            var          encryptedSecretConfigValue = "Encrypted string";

            using (var connection = GetDatabaseConnection(instanceName))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(23456, ApiMode.DistrictSpecific))
                .Returns(connection);

                var odsInstanceFirstTimeSetupService = GetOdsInstanceFirstTimeSetupService(encryptedSecretConfigValue, instanceName);

                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = 23456,
                    Description   = description
                };
                var testUsername = UserTestSetup.SetupUsers(1).Single().Id;

                var command       = new RegisterOdsInstanceCommand(odsInstanceFirstTimeSetupService, _connectionProvider.Object);
                var newInstanceId = await command.Execute(newInstance, ApiMode.DistrictSpecific, testUsername, new CloudOdsClaimSet());

                var addedInstance       = Query <OdsInstanceRegistration>(newInstanceId);
                var secretConfiguration =
                    SetupContext.SecretConfigurations.FirstOrDefault(x => x.OdsInstanceRegistrationId == newInstanceId);
                secretConfiguration.ShouldNotBeNull();
                secretConfiguration.EncryptedData.ShouldBe(encryptedSecretConfigValue);
                addedInstance.Name.ShouldBe(instanceName);
                addedInstance.Description.ShouldBe(newInstance.Description);
            }
        }
Beispiel #15
0
        public async Task <ActionResult> RegisterOdsInstance(RegisterOdsInstanceModel model)
        {
            var currentUserId = User.Identity.GetUserId();

            await _registerOdsInstanceCommand.Execute(model,
                                                      CloudOdsAdminAppSettings.Instance.Mode, currentUserId, CloudOdsAdminAppClaimSetConfiguration.Default);

            return(RedirectToAction("Index", "OdsInstances"));
        }
        public async Task BulkShouldNotRegisterOneOdsInstancePreviouslyRegistered()
        {
            ResetOdsInstanceRegistrations();
            const string instanceName = "23456";
            const string description  = "Test Description";
            const string encryptedSecretConfigValue = "Encrypted string";

            await using var connection  = GetDatabaseConnection(instanceName);
            await using var connection2 = GetDatabaseConnection(instanceName);
            await using var connection3 = GetDatabaseConnection(instanceName);
            await using var connection4 = GetDatabaseConnection(instanceName);
            await using var connection5 = GetDatabaseConnection(instanceName);

            _connectionProvider
            .SetupSequence(x => x.CreateNewConnection(23456, ApiMode.DistrictSpecific))
            .Returns(connection)
            .Returns(connection2)
            .Returns(connection3)
            .Returns(connection4)
            .Returns(connection5);

            var testUsername = UserTestSetup.SetupUsers(1).Single().Id;

            var odsInstancesToRegister = new List <RegisterOdsInstanceModel>();
            var repeatedInstance       = new RegisterOdsInstanceModel
            {
                NumericSuffix = 23456,
                Description   = description
            };

            odsInstancesToRegister.Add(repeatedInstance);

            var newInstances = await ScopedAsync <AdminAppIdentityDbContext, IEnumerable <BulkRegisterOdsInstancesResult> >(async identity =>
            {
                return(await ScopedAsync <AdminAppDbContext, IEnumerable <BulkRegisterOdsInstancesResult> >(async database =>
                {
                    var odsInstanceFirstTimeSetupService = GetOdsInstanceFirstTimeSetupService(encryptedSecretConfigValue, instanceName, database);
                    var inferInstanceService = new InferInstanceService(_connectionProvider.Object);

                    var registerOdsInstanceCommand = new RegisterOdsInstanceCommand(odsInstanceFirstTimeSetupService, identity, _setCurrentSchoolYear, inferInstanceService);

                    var command = new BulkRegisterOdsInstancesCommand(registerOdsInstanceCommand, _dataFiltrationService.Object);
                    return await command.Execute(odsInstancesToRegister, new List <RegisterOdsInstanceModel>(), ApiMode.DistrictSpecific, testUsername, new CloudOdsClaimSet());
                }));
            });

            var newInstance = newInstances.FirstOrDefault();

            newInstance.ShouldNotBeNull();
            newInstance.NumericSuffix.ShouldBe(repeatedInstance.NumericSuffix.ToString());
            newInstance.Description.ShouldBe(repeatedInstance.Description);
            newInstance.OdsInstanceRegisteredId.ShouldBe(0);
            newInstance.IndividualInstanceResult.ShouldBe(IndividualInstanceResult.Skipped);
        }
Beispiel #17
0
        public void ShouldNotRegisterInstanceIfRequiredFieldsEmpty()
        {
            ResetOdsInstanceRegistrations();

            var newInstance = new RegisterOdsInstanceModel();

            _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

            new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
            .ShouldNotValidate(newInstance,
                               "'ODS Instance District / EdOrg Id' must not be empty.",
                               "'ODS Instance Description' must not be empty.");
        }
        public async Task ShouldRegisterDistrictSpecificOdsInstance()
        {
            var apiMode = ApiMode.DistrictSpecific;

            ResetOdsInstanceRegistrations();
            var          instanceName = "23456";
            const string description  = "Test Description";
            var          encryptedSecretConfigValue = "Encrypted string";


            using (var connection = GetDatabaseConnection(instanceName, _dbNamePrefix))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(23456, apiMode))
                .Returns(connection);

                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = 23456,
                    Description   = description
                };

                var testUsername = UserTestSetup.SetupUsers(1).Single().Id;

                int newInstanceId = await ScopedAsync <AdminAppIdentityDbContext, int>(async identity =>
                {
                    return(await ScopedAsync <AdminAppDbContext, int>(async database =>
                    {
                        var odsInstanceFirstTimeSetupService = GetOdsInstanceFirstTimeSetupService(encryptedSecretConfigValue, instanceName, database, apiMode);
                        var inferInstanceService = new InferInstanceService(_connectionProvider.Object);

                        var command = new RegisterOdsInstanceCommand(odsInstanceFirstTimeSetupService, identity, _setCurrentSchoolYear.Object, inferInstanceService);
                        return await command.Execute(newInstance, apiMode, testUsername, new CloudOdsClaimSet());
                    }));
                });

                var addedInstance       = Query <OdsInstanceRegistration>(newInstanceId);
                var secretConfiguration = Transaction(database =>
                                                      database.SecretConfigurations.FirstOrDefault(x => x.OdsInstanceRegistrationId == newInstanceId));
                secretConfiguration.ShouldNotBeNull();
                secretConfiguration.EncryptedData.ShouldBe(encryptedSecretConfigValue);
                addedInstance.Name.ShouldBe(instanceName);
                addedInstance.Description.ShouldBe(newInstance.Description);
                addedInstance.DatabaseName.ShouldBe($"{_dbNamePrefix}{instanceName}");

                _setCurrentSchoolYear.Verify(
                    x => x.Execute(It.IsAny <string>(), It.IsAny <ApiMode>(), It.IsAny <short>()),
                    Times.Never());
            }
        }
        public async Task ShouldRegisterOneNewOdsInstanceInBulk()
        {
            ResetOdsInstanceRegistrations();
            const string instanceName = "23456";
            const string description  = "Test Description";
            const string encryptedSecretConfigValue = "Encrypted string";

            await using (var connection = GetDatabaseConnection(instanceName, "EdFi_Ods_"))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(23456, ApiMode.DistrictSpecific))
                .Returns(connection);

                var odsInstancesToRegister = new List <RegisterOdsInstanceModel>();
                var newInstance1           = new RegisterOdsInstanceModel
                {
                    NumericSuffix = 23456,
                    Description   = description
                };

                odsInstancesToRegister.Add(newInstance1);

                var testUsername = UserTestSetup.SetupUsers(1).Single().Id;

                var newInstances = await ScopedAsync <AdminAppIdentityDbContext, IEnumerable <BulkRegisterOdsInstancesResult> >(async identity =>
                {
                    return(await ScopedAsync <AdminAppDbContext, IEnumerable <BulkRegisterOdsInstancesResult> >(async database =>
                    {
                        var odsInstanceFirstTimeSetupService = GetOdsInstanceFirstTimeSetupService(encryptedSecretConfigValue, instanceName, database);
                        var inferInstanceService = new InferInstanceService(_connectionProvider.Object);

                        var registerOdsInstanceCommand = new RegisterOdsInstanceCommand(odsInstanceFirstTimeSetupService, identity, _setCurrentSchoolYear, inferInstanceService);

                        var command = new BulkRegisterOdsInstancesCommand(registerOdsInstanceCommand, _dataFiltrationService.Object);
                        return await command.Execute(odsInstancesToRegister, odsInstancesToRegister, ApiMode.DistrictSpecific, testUsername, new CloudOdsClaimSet());
                    }));
                });

                var addedInstance       = Query <OdsInstanceRegistration>(newInstances.FirstOrDefault().OdsInstanceRegisteredId);
                var secretConfiguration = Transaction(database =>
                                                      database.SecretConfigurations.FirstOrDefault(x => x.OdsInstanceRegistrationId == newInstances.FirstOrDefault().OdsInstanceRegisteredId));
                secretConfiguration.ShouldNotBeNull();
                secretConfiguration.EncryptedData.ShouldBe(encryptedSecretConfigValue);
                addedInstance.Name.ShouldBe(instanceName);
                addedInstance.Description.ShouldBe(newInstance1.Description);
                addedInstance.DatabaseName.ShouldBe($"EdFi_Ods_{instanceName}");
            }
        }
        public void ShouldBeInvalidDistrictOrEdOrgId(int invalidId)
        {
            using (var connection = GetDatabaseConnection("Test_Ods_" + invalidId))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(invalidId, ApiMode.DistrictSpecific))
                .Returns(connection);

                _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = invalidId,
                    Description   = Sample("Description")
                };

                new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                .ShouldNotValidate(newInstance,
                                   "'ODS Instance District / EdOrg Id' must be a valid positive integer.");
            }
        }
        public void ShouldBeInvalidSchoolYear(int?invalidSchoolYear)
        {
            using (var connection = GetDatabaseConnection("Test_Ods_" + invalidSchoolYear))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(invalidSchoolYear ?? 0, ApiMode.YearSpecific))
                .Returns(connection);

                _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);
                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = invalidSchoolYear,
                    Description   = Sample("Description")
                };

                new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                .ShouldNotValidate(newInstance,
                                   invalidSchoolYear == null
                        ? "'ODS Instance School Year' must not be empty."
                        : "'ODS Instance School Year' must be between 1900 and 2099.");
            }
        }
        public void ShouldValidateValidInstanceOnYearSpecificMode()
        {
            ResetOdsInstanceRegistrations();

            using (var connection = GetDatabaseConnection("TestInstance_2020"))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(2020, ApiMode.YearSpecific))
                .Returns(connection);

                _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.YearSpecific);

                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = 2020,
                    Description   = Sample("Description")
                };

                new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                .ShouldValidate(newInstance);
            }
        }
        public void ShouldNotRegisterInstanceIfOdsInstanceDescriptionNotUnique()
        {
            ResetOdsInstanceRegistrations();
            var instance = SetupOdsInstanceRegistration("Test_Ods_8787877");

            using (var connection = GetDatabaseConnection("Test_Ods_7878787"))
            {
                _connectionProvider.Setup(x => x.CreateNewConnection(7878787, ApiMode.DistrictSpecific))
                .Returns(connection);

                _apiModeProvider.Setup(x => x.GetApiMode()).Returns(ApiMode.DistrictSpecific);

                var newInstance = new RegisterOdsInstanceModel
                {
                    NumericSuffix = 7878787,
                    Description   = instance.Description
                };

                new RegisterOdsInstanceModelValidator(SetupContext, _apiModeProvider.Object, _databaseValidationService.Object, _connectionProvider.Object)
                .ShouldNotValidate(newInstance, "An instance with this description already exists.");
            }
        }