コード例 #1
0
        public void ToString_ShouldReturnCorrectFormat()
        {
            var createCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource  = ApplicationResource.Create(createCmd);

            Assert.Equal($"{nameof(ApplicationResource)}: {resource.Id}-{resource.Name}", resource.ToString());
        }
コード例 #2
0
        public void Create_ShoudThrowDomainValidationException_WhenCommandIsInvalid(CreateApplicationResourceCommand command, ValidationError[] errors)
        {
            var ex = Assert.Throws <DomainValidationException>(() => ApplicationResource.Create(command));

            Assert.Equal(errors.Length, ex.ValidationErrors.Count());
            Assert.All(ex.ValidationErrors, e => errors.Any(er => er.Code == e.Code && er.Member == e.Member));
        }
コード例 #3
0
        public void Create_ShouldThrowDomainValidationException_WhenRoleLevelIsAccountAndNoAccountIdsProvided(ApplicationLevel level, string errorCode)
        {
            var createAppResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;

            createAppResourceCmd.ApplicationLevel = level;
            var appResource = ApplicationResource.Create(createAppResourceCmd);

            var addActionCmd = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action       = appResource.AddResourceAction(addActionCmd);

            var roleCmdGen    = new RoleCmdGenerator();
            var createRoleCmd = roleCmdGen.CreateRoleCommand;

            createRoleCmd.ApplicationLevel = level;
            var role = Role.Create(createRoleCmd);
            var updateRolePermissions = roleCmdGen.UpdateRolePermissionsCommand;

            updateRolePermissions.Permissions.First().Action = action;

            role.UpdatePermissions(updateRolePermissions);

            var userCmdGen    = new UserCmdGenerator();
            var createUserCmd = userCmdGen.CreateUserCommand;

            createUserCmd.UserRoles = new[] { new UserCommandRole {
                                                  Role = role
                                              } };

            var ex = Assert.Throws <DomainValidationException>(() => User.Create(createUserCmd));

            Assert.Single(ex.ValidationErrors);
            Assert.Equal(errorCode, ex.ValidationErrors.Single().Code);
        }
コード例 #4
0
        public void UpdatePermissions_ShouldAddRolePermissionsUpdatedEvent_WhenCommandIsValid()
        {
            var roleCmdGen        = new RoleCmdGenerator();
            var createCmd         = roleCmdGen.CreateRoleCommand;
            var role              = Role.Create(createCmd);
            var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource          = ApplicationResource.Create(createResourceCmd);
            var action            = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
            var addPermissionCmd  = roleCmdGen.UpdateRolePermissionsCommand;

            addPermissionCmd.Permissions.First().Action = action;

            try
            {
                role.UpdatePermissions(addPermissionCmd);
            }
            catch (DomainValidationException ex)
            {
                Assert.True(false, Newtonsoft.Json.JsonConvert.SerializeObject(ex.ValidationErrors));
            }

            Assert.Equal(2, role.Events.Count());

            var addedEvent = Assert.IsType <RolePermissionsUpdatedEvent>(role.Events.Last());

            Assert.Equal(role.RolePermissions.Count(), addedEvent.Permissions.Count());
            Assert.All(role.RolePermissions, (item)
                       => Assert.Contains(addedEvent.Permissions, evi => evi.Action.Id == item.Action.Id && evi.Permission == item.Permission));
        }
コード例 #5
0
        public void UpdatePermissions_ShouldUpdatePermissions_WhenCommandIsValid()
        {
            var roleCmdGen        = new RoleCmdGenerator();
            var createCmd         = roleCmdGen.CreateRoleCommand;
            var role              = Role.Create(createCmd);
            var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource          = ApplicationResource.Create(createResourceCmd);
            var action            = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
            var command           = new UpdateRolePermissionsCommand
            {
                Permissions = new[] { new UpdateRolePermissionItem {
                                          Action = action, Permission = Permission.Allow
                                      } }
            };

            try
            {
                role.UpdatePermissions(command);
            }
            catch (DomainValidationException ex)
            {
                Assert.True(false, Newtonsoft.Json.JsonConvert.SerializeObject(ex.ValidationErrors));
            }

            Assert.Contains(role.RolePermissions,
                            p => p.Action == command.Permissions.Single().Action &&
                            p.Permission == command.Permissions.Single().Permission);
        }
コード例 #6
0
        public void RemoveResourceAction_ShouldAddApplicationResourceActionRemovedEvent_WhenCommandIsValid()
        {
            var createCmd   = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(createCmd);

            var addActionCommand = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action           = newResource.AddResourceAction(addActionCommand);

            // Set the Id through reflaction because it's private and generated by the database.
            // Doing this we can confirm that the event contains the right informationl
            var actionIdProp = action.GetType().GetProperty(nameof(ResourceAction.Id));

            actionIdProp.SetValue(action, 42);

            var newResourceIdProp = newResource.GetType().GetProperty(nameof(ApplicationResource.Id));

            newResourceIdProp.SetValue(newResource, 42);

            newResource.RemoveResourceAction(new RemoveResourceActionCommand {
                Action = action
            });
            var @event = Assert.IsType <ApplicationResourceActionRemovedEvent>(newResource.Events.Last());

            Assert.Equal(newResource.Id, @event.Id);
            Assert.Equal(action.Id, @event.ResourceActionId);
        }
コード例 #7
0
        public void Create_ShoudAddApplicationResourceCreatedEvent_WhenCommandIsValid()
        {
            var command     = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(command);

            Assert.Single(newResource.Events);
            Assert.IsType <ApplicationResourceCreatedEvent>(newResource.Events.Single());
        }
コード例 #8
0
        public void FullName_ShouldReturnCorrectFormat()
        {
            var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource          = ApplicationResource.Create(createResourceCmd);
            var addActionCmd      = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action            = resource.AddResourceAction(addActionCmd);

            Assert.Equal(action.FullName, action.FullName);
        }
コード例 #9
0
        public void AddResourceAction_ShouReturnTheNewAddedAction_WhenCommandIsValid()
        {
            var createCmd        = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource      = ApplicationResource.Create(createCmd);
            var addActionCommand = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action           = newResource.AddResourceAction(addActionCommand);

            Assert.Equal(addActionCommand.Name, action.Name);
        }
コード例 #10
0
        public void ToString_ShouldReturnCorrectFormat()
        {
            var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource          = ApplicationResource.Create(createResourceCmd);
            var addActionCmd      = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action            = resource.AddResourceAction(addActionCmd);

            Assert.Equal($"{nameof(ResourceAction)}: {action.Id}-{action.Name}", action.ToString());
        }
コード例 #11
0
        public void RemoveResourceAction_ShouldThrowDomainValidationException_WhenCommandIsInvalid(RemoveResourceActionCommand command,
                                                                                                   ValidationError[] errors)
        {
            var newResource = ApplicationResource.Create(ApplicationResourceCmdGenerator.CreateApplicationResourceCommand);

            var ex = Assert.Throws <DomainValidationException>(() => newResource.RemoveResourceAction(command));

            Assert.All(ex.ValidationErrors, e => Assert.Contains(e, errors));
        }
コード例 #12
0
        public void AddResourceAction_ShouThrowDomainValidationException_WhenCommandIsInvalid(AddResourceActionCommand command, ValidationError[] errors)
        {
            var createCmd   = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(createCmd);

            var ex = Assert.Throws <DomainValidationException>(() => newResource.AddResourceAction(command));

            Assert.Equal(errors.Length, ex.ValidationErrors.Count());
            Assert.All(ex.ValidationErrors, e => errors.Any(er => er.Code == e.Code && er.Member == e.Member));
        }
コード例 #13
0
        public void UpdateResourceAction_ShouldThrowDomainValidationException_WhenCommandIsInvalid(UpdateResourceActionCommand command, ValidationError[] errors)
        {
            var createCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource  = ApplicationResource.Create(createCmd);

            var ex = Assert.Throws <DomainValidationException>(() => resource.UpdateAction(command));

            Assert.Equal(errors.Length, ex.ValidationErrors.Count());
            Assert.All(ex.ValidationErrors, err => errors.Contains(err));
        }
コード例 #14
0
        public void Update_ShoudUpdatePropertiesCorrectly_WhenCommandIsValid()
        {
            var createCmd     = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource   = ApplicationResource.Create(createCmd);
            var updateCommand = ApplicationResourceCmdGenerator.UpdateApplicationResourceCommand;

            newResource.Update(updateCommand);

            Assert.Equal(updateCommand.Name, newResource.Name);
            Assert.Equal(updateCommand.ApplicationLevel, newResource.ApplicationLevel);
        }
コード例 #15
0
        public void GetHashCode_ShouldCalculateCorrectHashValue()
        {
            var resource  = ApplicationResource.Create(ApplicationResourceCmdGenerator.CreateApplicationResourceCommand);
            var resource2 = ApplicationResource.Create(ApplicationResourceCmdGenerator.CreateApplicationResourceCommand);

            var addActionCmd     = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var resource1action1 = resource.AddResourceAction(addActionCmd);
            var resource1action2 = resource2.AddResourceAction(addActionCmd);

            Assert.True(resource1action1.Name == resource1action2.Name && resource1action1.GetHashCode() == resource1action2.GetHashCode());
        }
コード例 #16
0
        public void AddResourceAction_ShouAddTheNewActionToAvailableActionsList_WhenCommandIsValid()
        {
            var createCmd        = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource      = ApplicationResource.Create(createCmd);
            var addActionCommand = ApplicationResourceCmdGenerator.AddResourceActionCommand;

            newResource.AddResourceAction(addActionCommand);

            var action = newResource.AvailableActions.Single();

            Assert.Equal(addActionCommand.Name, action.Name);
        }
コード例 #17
0
    static void Main(string[] args)
    {
        // Find your Account Sid and Token at twilio.com/console
        const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
        const string authToken  = "your_auth_token";

        TwilioClient.Init(accountSid, authToken);

        var application = ApplicationResource.Create(friendlyName: "FriendlyName");

        Console.WriteLine(application.Sid);
    }
コード例 #18
0
        public void Update_ShoudAddApplicationResourceUpdatedEvent_WhenCommandIsValid()
        {
            var createCmd     = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource   = ApplicationResource.Create(createCmd);
            var updateCommand = ApplicationResourceCmdGenerator.UpdateApplicationResourceCommand;

            newResource.Update(updateCommand);
            var @event = Assert.IsType <ApplicationResourceUpdatedEvent>(newResource.Events.Last());


            Assert.Equal(updateCommand.Name, @event.Name);
            Assert.Equal(updateCommand.ApplicationLevel, @event.ApplicationLevel);
        }
コード例 #19
0
    static void Main(string[] args)
    {
        // Find your Account Sid and Token at twilio.com/console
        // DANGER! This is insecure. See http://twil.io/secure
        const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
        const string authToken  = "your_auth_token";

        TwilioClient.Init(accountSid, authToken);

        var application = ApplicationResource.Create(friendlyName: "friendly_name");

        Console.WriteLine(application.Sid);
    }
コード例 #20
0
        public void UpdatePermissions_ShouldThrowDomainValidaitonException_WhenCommandIsInvalid(UpdateRolePermissionsCommand command, ValidationError[] errors)
        {
            var roleCmdGen        = new RoleCmdGenerator();
            var createCmd         = roleCmdGen.CreateRoleCommand;
            var role              = Role.Create(createCmd);
            var createResourceCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource          = ApplicationResource.Create(createResourceCmd);
            var action            = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);

            var ex = Assert.Throws <DomainValidationException>(() => role.UpdatePermissions(command));

            Assert.Equal(errors.Length, ex.ValidationErrors.Count());
            Assert.All(ex.ValidationErrors, e => errors.Any(err => err.Code == e.Code && err.Member == e.Member));
        }
コード例 #21
0
        public void Delete_ShoudAddApplicationResourceDeletedEvent_WhenCalled()
        {
            var createCmd   = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(createCmd);

            var newResourceIdProp = newResource.GetType().GetProperty(nameof(ApplicationResource.Id));

            newResourceIdProp.SetValue(newResource, 42);

            newResource.Delete();
            var @event = Assert.IsType <ApplicationResourceDeletedEvent>(newResource.Events.Last());

            Assert.Equal(newResource.Id, @event.Id);
        }
コード例 #22
0
        public void AddResourceAction_ShouAddNewResourceActionAddedEvent_WhenNewResourceIsAdded()
        {
            var createCmd   = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(createCmd);

            var addActionCommand = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action           = newResource.AddResourceAction(addActionCommand);

            Assert.Equal(2, newResource.Events.Count());

            var addedEvent = Assert.IsType <NewResourceActionAddedEvent>(newResource.Events.Last());

            Assert.Equal(action.Name, addedEvent.Name);
        }
コード例 #23
0
        public void TestCreateResponse()
        {
            var twilioRestClient = Substitute.For <ITwilioRestClient>();

            twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
            twilioRestClient.Request(Arg.Any <Request>())
            .Returns(new Response(
                         System.Net.HttpStatusCode.Created,
                         "{\"account_sid\": \"ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"api_version\": \"2010-04-01\",\"date_created\": \"Mon, 22 Aug 2011 20:59:45 +0000\",\"date_updated\": \"Tue, 18 Aug 2015 16:48:57 +0000\",\"friendly_name\": \"Application Friendly Name\",\"message_status_callback\": \"http://www.example.com/sms-status-callback\",\"sid\": \"APaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"sms_fallback_method\": \"GET\",\"sms_fallback_url\": \"http://www.example.com/sms-fallback\",\"sms_method\": \"GET\",\"sms_status_callback\": \"http://www.example.com/sms-status-callback\",\"sms_url\": \"http://example.com\",\"status_callback\": \"http://example.com\",\"status_callback_method\": \"GET\",\"uri\": \"/2010-04-01/Accounts/ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Applications/APaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.json\",\"voice_caller_id_lookup\": false,\"voice_fallback_method\": \"GET\",\"voice_fallback_url\": \"http://www.example.com/voice-callback\",\"voice_method\": \"GET\",\"voice_url\": \"http://example.com\"}"
                         ));

            var response = ApplicationResource.Create("FriendlyName", client: twilioRestClient);

            Assert.NotNull(response);
        }
コード例 #24
0
    static void Main(string[] args)
    {
        // Find your Account Sid and Auth Token at twilio.com/console
        const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
        const string authToken  = "your_auth_token";

        TwilioClient.Init(accountSid, authToken);

        var app = ApplicationResource.Create(
            "Phone Me",
            voiceUrl: new Uri("http://demo.twilio.com/docs/voice.xml"),
            voiceMethod: HttpMethod.Get);

        Console.WriteLine(app.Sid);
    }
コード例 #25
0
    static void Main(string[] args)
    {
        // Find your Account Sid and Auth Token at twilio.com/console
        // To set up environmental variables, see http://twil.io/secure
        const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        const string authToken  = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var app = ApplicationResource.Create(
            "Phone Me",
            voiceUrl: new Uri("http://demo.twilio.com/docs/voice.xml"),
            voiceMethod: HttpMethod.Get);

        Console.WriteLine(app.Sid);
    }
コード例 #26
0
        public void RemoveResourceAction_ShouldRemoveOnlyTheRightItemFromCollection_WhenCommandIsValid()
        {
            var createCmd   = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var newResource = ApplicationResource.Create(createCmd);

            var addActionCommand = ApplicationResourceCmdGenerator.AddResourceActionCommand;
            var action           = newResource.AddResourceAction(addActionCommand);
            var action2          = newResource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);

            newResource.RemoveResourceAction(new RemoveResourceActionCommand {
                Action = action
            });

            Assert.DoesNotContain(action, newResource.AvailableActions);
            Assert.Contains(action2, newResource.AvailableActions);
        }
コード例 #27
0
        public void UpdateResourceAction_ShouldUpdateTheRightAction_WhenCommandIsValid()
        {
            var createCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource  = ApplicationResource.Create(createCmd);
            var action    = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);
            var action2   = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);

            var updateActionCmd = ApplicationResourceCmdGenerator.UpdateResourceActionCommand;

            updateActionCmd.Action = action;

            resource.UpdateAction(updateActionCmd);

            Assert.Equal(updateActionCmd.Name, action.Name);
            Assert.NotEqual(updateActionCmd.Name, action2.Name);
        }
コード例 #28
0
    static void Main(string[] args)
    {
        // Find your Account Sid and Token at twilio.com/console
        // DANGER! This is insecure. See http://twil.io/secure
        const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
        const string authToken  = "your_auth_token";

        TwilioClient.Init(accountSid, authToken);

        var application = ApplicationResource.Create(
            voiceMethod: Twilio.Http.HttpMethod.Get,
            voiceUrl: new Uri("http://demo.twilio.com/docs/voice.xml"),
            friendlyName: "Phone Me"
            );

        Console.WriteLine(application.Sid);
    }
コード例 #29
0
        public void UpdateResourceAction_ShouldAddApplicationResourceActionUpdatedEvent_WhenCommandIsValid()
        {
            var createCmd = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource  = ApplicationResource.Create(createCmd);
            var action    = resource.AddResourceAction(ApplicationResourceCmdGenerator.AddResourceActionCommand);

            var updateActionCmd = ApplicationResourceCmdGenerator.UpdateResourceActionCommand;

            updateActionCmd.Action = action;

            resource.UpdateAction(updateActionCmd);

            var @event = Assert.IsType <ApplicationResourceActionUpdatedEvent>(resource.Events.Last());

            Assert.Equal(resource.Id, @event.Id);
            Assert.Equal(action.Id, @event.ResourceActionId);
            Assert.Equal(action.Name, @event.Name);
        }
コード例 #30
0
        public void UpdateResourceAction_ShouldThrowDomainValidationException_WhenActionDoesNotBelongToResource()
        {
            var createCmd    = ApplicationResourceCmdGenerator.CreateApplicationResourceCommand;
            var resource     = ApplicationResource.Create(createCmd);
            var resource2    = ApplicationResource.Create(createCmd);
            var addActionCmd = ApplicationResourceCmdGenerator.AddResourceActionCommand;

            // Add action to resource 2 and try to update on resource 1
            var action          = resource2.AddResourceAction(addActionCmd);
            var updateActionCmd = ApplicationResourceCmdGenerator.UpdateResourceActionCommand;

            updateActionCmd.Action = action;

            var ex = Assert.Throws <DomainValidationException>(() => resource.UpdateAction(updateActionCmd));

            Assert.Single(ex.ValidationErrors);
            Assert.Equal(ValidationErrorCode.InvalidReferece, ex.ValidationErrors.Single().Code);
            Assert.Equal(nameof(UpdateResourceActionCommand.Action), ex.ValidationErrors.Single().Member);
        }