Ejemplo n.º 1
0
        //[Test]
        public void WindowsSkipsInstallWhenSettingsGitExists()
        {
            DefaultEnvironment.OnMac     = false;
            DefaultEnvironment.OnWindows = true;

            var filesystem = Substitute.For <IFileSystem>();

            filesystem.FileExists(Arg.Any <string>()).Returns(true);
            filesystem.DirectoryExists(Arg.Any <string>()).Returns(true);
            filesystem.DirectorySeparatorChar.Returns('\\');
            Environment.FileSystem = filesystem;

            var gitInstallationPath    = "c:/Program Files/Git".ToNPath();
            var gitExecutablePath      = gitInstallationPath.Combine("cmd/git.exe");
            var gitLfsInstallationPath = gitInstallationPath;
            var gitLfsExecutablePath   = gitLfsInstallationPath.Combine("mingw32/libexec/git-core/git-lfs.exe");

            var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, Environment.IsWindows)
            {
                GitPackageFeed    = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitPackageName}",
                GitLfsPackageFeed = $"http://localhost:{server.Port}/unity/git/windows/{GitInstaller.GitInstallDetails.GitLfsPackageName}",
            };

            var ret = new string[] { gitLfsExecutablePath };

            filesystem.GetFiles(Arg.Any <string>(), Arg.Is <string>(installDetails.GitLfsExecutablePath.FileName), Arg.Any <SearchOption>())
            .Returns(ret);

            var settings    = Substitute.For <ISettings>();
            var settingsRet = gitExecutablePath.ToString();

            settings.Get(Arg.Is <string>(Constants.GitInstallPathKey), Arg.Any <string>()).Returns(settingsRet);
            var installer = new GitInstaller(Environment, ProcessManager, TaskManager.Token, installDetails);
            var result    = installer.SetupGitIfNeeded();

            Assert.AreEqual(gitInstallationPath, result.GitInstallationPath);
            Assert.AreEqual(gitLfsInstallationPath, result.GitLfsInstallationPath);
            Assert.AreEqual(gitExecutablePath, result.GitExecutablePath);
            Assert.AreEqual(gitLfsExecutablePath, result.GitLfsExecutablePath);
        }
Ejemplo n.º 2
0
        public async Task UpdateUser_GivenUserSubmit_ReturnsUserResource()
        {
            var userRepository        = Substitute.For <IUserRepository>();
            var roleRepository        = Substitute.For <IRoleRepository>();
            var teamRepository        = Substitute.For <ITeamRepository>();
            var ldapRepository        = Substitute.For <ILdapAuthenticationModeRepository>();
            var ldapConnectionService = Substitute.For <ILdapConnectionService>();

            var guid          = Guid.NewGuid();
            var userModelMock = new UserModel
            {
                UserName  = "******",
                Id        = guid.ToString(),
                FirstName = "Test User Firstname",
                Surname   = "Test User Surname",
                Email     = "Test User Email"
            };

            var userSubmit = new UserSubmit()
            {
                Uuid     = guid,
                Username = userModelMock.UserName,
                Name     = userModelMock.FirstName,
                Surname  = userModelMock.Surname,
                Email    = userModelMock.Email
            };

            userRepository.UpdateAsync(Arg.Any <UserModel>()).Returns(userModelMock);
            userRepository.GetByIdAsync(Arg.Any <Guid>(), Arg.Any <bool>()).Returns(userModelMock);

            var userService  = new UserService(userRepository, roleRepository, teamRepository, ldapRepository, mapper, ldapConnectionService);
            var userResource = await userService.UpdateAsync(userSubmit, Guid.NewGuid());

            Assert.NotNull(userResource);
            Assert.True(userResource.Uuid.ToString() == userModelMock.Id, $"User resource Id: '{userResource.Uuid}' does not match expected value: '{userModelMock.Id}'");
            Assert.True(userResource.Name == userModelMock.FirstName, $"User resource name: '{userResource.Name}' does not match expected value: '{userModelMock.FirstName}'");
            Assert.True(userResource.Surname == userModelMock.Surname, $"User resource surname: '{userResource.Surname}' does not match expected value: '{userModelMock.Surname}'");
            Assert.True(userResource.Username == userModelMock.UserName, $"User resource username: '******' does not match expected value: '{userModelMock.UserName}'");
            Assert.True(userResource.Email == userModelMock.Email, $"User resource email: '{userResource.Email}' does not match expected value: '{userModelMock.Email}'");
        }
Ejemplo n.º 3
0
    public void SimonSolvedWithWrongAnswersTest(IMiniGameEventManager miniGameEventManager, string miniGameId, int inputCount, int inputSequenceCount, int failureThreshold)
    {
        bool miniGameSolved     = false;
        int  wrongAnswerCount   = 0;
        int  correctAnswerCount = 0;
        bool miniGameFailed     = false;

        miniGameEventManager.OnMiniGameInputReceived(
            Arg.Any <string>(),
            Arg.Do <InputResults>(x => {
            if (x.Equals(InputResults.FAIL))
            {
                wrongAnswerCount++;
            }
            if (x.Equals(InputResults.PASS))
            {
                correctAnswerCount++;
            }
        }),
            Arg.Any <int>()
            );
        miniGameEventManager.When(x => x.OnMiniGameFailed(miniGameId)).Do(x => miniGameFailed = true);
        miniGameEventManager.When(x => x.OnMiniGameSolved(miniGameId)).Do(x => miniGameSolved = true);

        Simon simon = new Simon(miniGameEventManager, miniGameId, inputCount, inputSequenceCount, failureThreshold);

        int[] inputSequence = simon.GetInputSequence();

        simon.VerifyInput(simon.GetInputIds().Length + 1);

        foreach (int input in inputSequence)
        {
            simon.VerifyInput(input);
        }

        Assert.IsTrue(miniGameSolved);
        Assert.IsTrue(!miniGameFailed);
        Assert.AreEqual(simon.GetInputSequence().Length, correctAnswerCount);
        Assert.AreEqual(simon.GetFailureCount(), wrongAnswerCount);
    }
Ejemplo n.º 4
0
        public void Delete_Command_Variable_Should_Throw_With_Invalid_Command_Name()
        {
            // Arrange
            batchRepository.DoesBatchExist(Arg.Any <string>())
            .Returns(true);

            stepRepository.Get(Arg.Any <string>(), Arg.Any <string>())
            .Returns(new Step());

            commandRepository.Get(Arg.Any <ulong>(), Arg.Any <string>()).ReturnsNull();

            var request = new DeleteCommandVariableRequest
            {
                CommandName = TestCommandName
            };

            // Act / Assert
            var exception = Assert.ThrowsAsync <HttpError>(() => Sut.Delete(request));

            exception.ErrorCode.Should().Be(HttpStatusCode.NotFound.ToString());
            exception.Message.Should().Be("Command TestCommand not found");
        }
Ejemplo n.º 5
0
        public void AttemptsToAquireLockIfOtherProcessIsNoLongerRunning()
        {
            var log           = new InMemoryLog();
            var lockIo        = Substitute.For <ILockIo>();
            var name          = Guid.NewGuid().ToString();
            var processFinder = Substitute.For <IProcessFinder>();

            processFinder.ProcessIsRunning(Arg.Any <int>(), Arg.Any <string>()).Returns(false);
            var semaphore = new LockFileBasedSemaphore(name, TimeSpan.FromSeconds(30), lockIo, processFinder, log);
            var fileLock  = new FileLock
            {
                ProcessId   = -1,
                ThreadId    = -2,
                ProcessName = Guid.NewGuid().ToString()
            };

            lockIo.LockExists(Arg.Any <string>()).Returns(true);
            var result = semaphore.ShouldAquireLock(fileLock);

            Assert.That(result, Is.EqualTo(LockFileBasedSemaphore.AquireLockAction.AquireLock));
            log.Messages.Should().Contain(m => m.Level == InMemoryLog.Level.Warn && m.FormattedMessage == "Process -1, thread -2 had lock, but appears to have crashed. Taking lock.");
        }
Ejemplo n.º 6
0
    public void ShouldNotCreateAssemblyInfoFileForUnknownSourceCodeAndEnsureAssemblyInfo()
    {
        var fileSystem       = Substitute.For <IFileSystem>();
        var workingDir       = Path.GetTempPath();
        var assemblyInfoFile = new HashSet <string>
        {
            "VersionAssemblyInfo.js"
        };
        var fullPath  = Path.Combine(workingDir, assemblyInfoFile.First());
        var variables = VariableProvider.GetVariablesFor(SemanticVersion.Parse("1.0.0", "v"), new TestEffectiveConfiguration(), false);
        var arguments = new Arguments
        {
            EnsureAssemblyInfo         = true,
            UpdateAssemblyInfo         = true,
            UpdateAssemblyInfoFileName = assemblyInfoFile
        };

        using (new AssemblyInfoFileUpdate(arguments, workingDir, variables, fileSystem))
        {
            fileSystem.Received(0).WriteAllText(fullPath, Arg.Any <string>());
        }
    }
            public void PropagatesErrorIfUpdateFails()
            {
                var timeEntry = Models.TimeEntry.Builder.Create(12)
                                .SetStart(Now)
                                .SetSyncStatus(SyncStatus.InSync)
                                .SetDescription("")
                                .SetUserId(11)
                                .SetWorkspaceId(10)
                                .SetAt(Now)
                                .Build();

                var timeEntryObservable = Observable.Return(timeEntry);
                var errorObservable     = Observable.Throw <IDatabaseTimeEntry>(new DatabaseOperationException <IDatabaseTimeEntry>(new Exception()));

                Repository.GetById(Arg.Is(timeEntry.Id)).Returns(timeEntryObservable);
                Repository.Update(Arg.Any <long>(), Arg.Any <IDatabaseTimeEntry>()).Returns(errorObservable);
                var observer = Substitute.For <IObserver <Unit> >();

                TimeEntriesSource.SoftDelete(timeEntry).Subscribe(observer);

                observer.Received().OnError(Arg.Any <DatabaseOperationException <IDatabaseTimeEntry> >());
            }
Ejemplo n.º 8
0
            public void IgnoresEmailIfNullOrEmpty()
            {
                var coreSettings = new CoreSettings {
                    EnableAutomaticReports = true
                };
                var endpoint = Substitute.For <IAnalyticsEndpoint>();
                var client   = new AnalyticsClient(endpoint);

                client.Initialize(coreSettings);

                client.RecordBugReport("blabla");

                endpoint.DidNotReceiveWithAnyArgs().UpdateEmail(Arg.Any <string>());

                client.RecordBugReport("blabla", String.Empty);

                endpoint.DidNotReceiveWithAnyArgs().UpdateEmail(Arg.Any <string>());

                client.RecordBugReport("blabla", "  ");

                endpoint.DidNotReceiveWithAnyArgs().UpdateEmail(null);
            }
        public async Task PostRegister_ShouldRegisterUser()
        {
            var passwordHash = "abcdef";
            var token        = "123456";
            var userGuid     = new Guid();

            _userService.RegisterUserAsync(Arg.Any <User>(), passwordHash, token, userGuid)
            .Returns(Task.FromResult(IdentityResult.Success));
            var request = new RegisterRequestModel
            {
                Name  = "Example User",
                Email = "*****@*****.**",
                MasterPasswordHash = passwordHash,
                MasterPasswordHint = "example",
                Token = token,
                OrganizationUserId = userGuid
            };

            await _sut.PostRegister(request);

            await _userService.Received(1).RegisterUserAsync(Arg.Any <User>(), passwordHash, token, userGuid);
        }
Ejemplo n.º 10
0
        public void Setup()
        {
            _fc = Substitute.For <IFieldConfiguration>();

            _f = Substitute.For <IForm <TestFieldViewModel, IFormTemplate> >();
            _f.Template.BeginField(_label, _field, _validation, _metadata, Arg.Any <IReadonlyFieldConfiguration>(), Arg.Any <bool>()).Returns(_beginHtml);
            _f.Template.Field(_label, _field, _validation, _metadata, Arg.Any <IReadonlyFieldConfiguration>(), Arg.Any <bool>()).Returns(_html);
            _f.Template.EndField().Returns(_endHtml);

            _g = Substitute.For <IFieldGenerator>();
            _g.GetLabelHtml(Arg.Any <IReadonlyFieldConfiguration>()).Returns(_label);
            _g.GetFieldHtml(Arg.Any <IReadonlyFieldConfiguration>()).Returns(_field);
            _g.GetValidationHtml(Arg.Any <IReadonlyFieldConfiguration>()).Returns(_validation);
            _g.Metadata.Returns(_metadata);
            _g.GetFieldId().Returns(FieldId);

            var autoSubstitute = AutoSubstituteContainer.Create();
            var helper         = autoSubstitute.Resolve <HtmlHelper <TestFieldViewModel> >();

            _f.HtmlHelper.Returns(helper);
            _f.GetFieldGenerator(Arg.Any <Expression <Func <TestFieldViewModel, string> > >()).Returns(_g);
        }
        private string SetupExistingChannel()
        {
            Repository.Client.RootDocument.Returns(new RootResource
            {
                Links = new LinkCollection().Add("Channels", "DOES_NOT_MATTER")
            });

            var projectName = $"Project-{Guid.NewGuid()}";
            var project     = new ProjectResource()
            {
                Links = new LinkCollection()
            };

            project.Links.Add("Channels", "DOES_NOT_MATTER");
            Repository.Projects.FindByName(projectName).Returns(project);

            var lifecycleName = $"Lifecycle-{Guid.NewGuid()}";

            Repository.Lifecycles.FindOne(Arg.Any <Func <LifecycleResource, bool> >())
            .Returns(new LifecycleResource {
                Id = lifecycleName
            });

            var channelName = $"Channel-{Guid.NewGuid()}";
            var channel     = new ChannelResource()
            {
                Id   = Guid.NewGuid().ToString(),
                Name = channelName
            };

            Repository.Projects.GetChannels(Arg.Any <ProjectResource>())
            .Returns(new ResourceCollection <ChannelResource>(new[] { channel }, new LinkCollection()));

            CommandLineArgs.Add($"--channel={channelName}");
            CommandLineArgs.Add($"--project={projectName}");
            CommandLineArgs.Add($"--lifecycle={lifecycleName}");
            CommandLineArgs.Add("--update-existing");
            return(channelName);
        }
Ejemplo n.º 12
0
        public async Task Given_ValidInputs_When_Sort_Returns_SortedProducts()
        {
            // Arrange.
            _productSort1.SupportedSortOptions.Returns(new List <SortOptions> {
                SortOptions.ASCENDING, SortOptions.DESCENDING
            });
            _productSort2.SupportedSortOptions.Returns(new List <SortOptions> {
                SortOptions.HIGH, SortOptions.LOW
            });

            var products = _fixture.CreateMany <Product>(5).ToList();

            _productsRepository.Get(Arg.Any <string>()).Returns(products);

            _productSort1.Sort(Arg.Any <SortOptions>(), Arg.Is <List <Product> >(products)).Returns(products);

            // Act.
            var result = await _sut.Sort("ASCENDING");

            // Assert.
            result.SequenceEqual(products);
        }
Ejemplo n.º 13
0
        public void Should_create_exchange_queue_and_put_error_to_queue()
        {
            // Arrange
            var durableConnection = Substitute.For <IDurableConnection>();

            var model = Substitute.For <IModel>();

            durableConnection.CreateChannel().Returns(model);
            var basicProperies = Substitute.For <IBasicProperties>();

            model.CreateBasicProperties().Returns(basicProperies);

            var handler = new ConsumerErrorHandler(durableConnection, Substitute.For <ISerializer>(), Substitute.For <IRabbitWatcher>());

            // Action
            handler.HandleError(new BasicDeliverEventArgs {
                Body = new byte[0], BasicProperties = basicProperies
            }, new Exception());

            // Assert
            model.Received().BasicPublish(Arg.Any <string>(), string.Empty, basicProperies, Arg.Any <byte[]>());
        }
Ejemplo n.º 14
0
    public void Execute_ProperlyHandlesSitauationWhenKeysAreNotUsed()
    {
        var licenseDialog = Substitute.For <ILicenseDialog>();

        var remoteMetaData = Substitute.For <IRemoteMetaData>();

        remoteMetaData.GetAppInfo().Returns(new App()
        {
            UseKeys = false
        });

        var localMetaData = Substitute.For <ILocalMetaData>();

        var command = new ValidateLicenseCommand(licenseDialog, remoteMetaData, localMetaData, _cache, _logger, _issueReporter);

        command.Prepare(_statusMonitor);
        command.Execute(CancellationToken.Empty);

        Assert.AreEqual(command.KeySecret, null);
        remoteMetaData.DidNotReceive().GetKeySecret(Arg.Any <string>(), Arg.Any <string>());
        licenseDialog.DidNotReceive().Display(Arg.Any <LicenseDialogMessageType>());
    }
Ejemplo n.º 15
0
            public void Should_Log_All_Analyzer_Errors_And_Throw()
            {
                // Given
                var fixture = new ScriptRunnerFixture();

                fixture.ScriptAnalyzer = Substitute.For <IScriptAnalyzer>();
                fixture.ScriptAnalyzer.Analyze(Arg.Any <FilePath>())
                .Returns(new ScriptAnalyzerResult(new ScriptInformation(fixture.Script), new List <string>(), new List <ScriptAnalyzerError>
                {
                    new ScriptAnalyzerError("/Working/script1.cake", 2, "Error in script 1"),
                    new ScriptAnalyzerError("/Working/script2.cake", 7, "Error in script 2")
                }));
                var runner = fixture.CreateScriptRunner();

                // When
                var exception = Record.Exception(() => runner.Run(fixture.Host, fixture.Script));

                // Then
                AssertEx.IsCakeException(exception, "Errors occurred while analyzing script.");
                Assert.Contains(fixture.Log.Entries, x => x.Level == LogLevel.Error && x.Message == "/Working/script1.cake:2: Error in script 1");
                Assert.Contains(fixture.Log.Entries, x => x.Level == LogLevel.Error && x.Message == "/Working/script2.cake:7: Error in script 2");
            }
        public void ProcessItem_ItemDoesNotExistInAllowedItems_DoesNotThrowException()
        {
            Guid      itemGuid   = Guid.NewGuid();
            IItemData remoteData = Substitute.For <IItemData>();

            remoteData.Id.Returns(itemGuid);
            GetSubstitute <IItemComparer>().Compare(Arg.Any <IItemData>(), Arg.Any <IItemData>()).Returns(CreateComparisonResult());
            var contentItemInstaller = CreateInstance <ContentItemInstaller>();

            contentItemInstaller.AllowedItems.Add(itemGuid);

            try
            {
                contentItemInstaller.ProcessItem(new PullItemModel {
                    Preview = true
                }, Substitute.For <IItemData>(), remoteData);
            }
            catch (Exception ex)
            {
                Assert.True(false, $"A {ex.GetType()} exception was thrown: {ex.Message}");
            }
        }
Ejemplo n.º 17
0
        public void Get_headers_when_blocks_are_missing()
        {
            var svc = Build.A.SerializationService().WithEth().TestObject;

            var session         = Substitute.For <ISession>();
            var syncManager     = Substitute.For <ISyncServer>();
            var transactionPool = Substitute.For <ITxPool>();

            syncManager.Find(null, Arg.Any <int>(), Arg.Any <int>(), Arg.Any <bool>()).Throws(new ArgumentNullException());
            Block genesisBlock = Build.A.Block.Genesis.TestObject;

            syncManager.Head.Returns(genesisBlock.Header);
            syncManager.Genesis.Returns(genesisBlock.Header);
            var handler = new Eth62ProtocolHandler(
                session,
                svc,
                new NodeStatsManager(new StatsConfig(), LimboLogs.Instance),
                syncManager,
                LimboLogs.Instance,
                new PerfService(LimboLogs.Instance),
                transactionPool);

            handler.Init();

            var msg = new GetBlockHeadersMessage();

            msg.StartingBlockNumber = 1920000;
            msg.MaxHeaders          = 3;
            msg.Skip    = 1;
            msg.Reverse = 1;

            var statusMsg = new StatusMessage();

            statusMsg.GenesisHash = genesisBlock.Hash;

            handler.HandleMessage(new Packet(Protocol.Eth, statusMsg.PacketType, svc.Serialize(statusMsg)));
            handler.HandleMessage(new Packet(Protocol.Eth, msg.PacketType, svc.Serialize(msg)));
            syncManager.Received().FindHeader(1920000);
        }
Ejemplo n.º 18
0
        public async void GivenRequestForStudies_WhenRetrievingQueriableExtendedQueryTags_ReturnsStudyTags(QueryResource resourceType)
        {
            var request = new QueryResourceRequest(
                Substitute.For <IEnumerable <KeyValuePair <string, StringValues> > >(),
                resourceType,
                TestUidGenerator.Generate(),
                TestUidGenerator.Generate());

            List <ExtendedQueryTagStoreEntry> storeEntries = new List <ExtendedQueryTagStoreEntry>()
            {
                new ExtendedQueryTagStoreEntry(1, "00741000", "CS", null, QueryTagLevel.Instance, ExtendedQueryTagStatus.Ready),
                new ExtendedQueryTagStoreEntry(2, "0040A121", "DA", null, QueryTagLevel.Series, ExtendedQueryTagStatus.Ready),
                new ExtendedQueryTagStoreEntry(3, "00101005", "PN", null, QueryTagLevel.Study, ExtendedQueryTagStatus.Ready),
            };

            var list = QueryTagService.CoreQueryTags.Concat(storeEntries.Select(item => new QueryTag(item))).ToList();

            _queryStore.QueryAsync(Arg.Any <QueryExpression>(), Arg.Any <CancellationToken>()).ReturnsForAnyArgs(new QueryResult(new List <VersionedInstanceIdentifier>()));
            await _queryService.QueryAsync(request, CancellationToken.None);

            _queryParser.Received().Parse(request, Arg.Do <IReadOnlyCollection <QueryTag> >(x => Assert.Equal(x, list, QueryTagComparer.Default)));
        }
Ejemplo n.º 19
0
        public void Should_Return_CodeLensResolve_Descriptor()
        {
            // Given
            var handlerMatcher  = new ResolveCommandMatcher(_logger);
            var resolveHandler  = Substitute.For <ICodeLensResolveHandler>();
            var resolveHandler2 = Substitute.For <ICodeLensResolveHandler>();

            resolveHandler.CanResolve(Arg.Any <CodeLens>()).Returns(false);
            resolveHandler2.CanResolve(Arg.Any <CodeLens>()).Returns(true);

            // When
            var result = handlerMatcher.FindHandler(new CodeLens()
            {
                Data = JToken.FromObject(new { handlerType = typeof(ICodeLensResolveHandler).FullName, data = new { a = 1 } })
            },
                                                    new List <HandlerDescriptor> {
                new HandlerDescriptor(DocumentNames.CodeLensResolve,
                                      "Key",
                                      resolveHandler,
                                      resolveHandler.GetType(),
                                      typeof(CodeLens),
                                      null,
                                      null,
                                      () => { }),
                new HandlerDescriptor(DocumentNames.CodeLensResolve,
                                      "Key2",
                                      resolveHandler2,
                                      typeof(ICodeLensResolveHandler),
                                      typeof(CodeLens),
                                      null,
                                      null,
                                      () => { }),
            })
                         .ToArray();

            // Then
            result.Should().NotBeNullOrEmpty();
            result.Should().Contain(x => x.Handler == resolveHandler2);
        }
Ejemplo n.º 20
0
        public void ValueWithRandomAdded_should_hold_passed_value_plus_random_value()
        {
            using (new IndirectionsContext())
            {
                // Arrange
                var notifyingObject = new NotifyingObject();

                var mockNext = Substitute.For <IndirectionFunc <Random, int> >();
                mockNext(Arg.Any <Random>()).Returns(10);
                PRandom.Next().Body = mockNext;


                // Act
                notifyingObject.ValueWithRandomAdded = 32;
                var actual = notifyingObject.ValueWithRandomAdded;


                // Assert
                mockNext.Received(1)(Arg.Any <Random>());
                Assert.AreEqual(42, actual);
            }
        }
Ejemplo n.º 21
0
        public void ContainsDelegatesToUnderlyingDictionary()
        {
            // given
            var jsonObjectDict = Substitute.For <IDictionary <string, JsonValue> >();

            jsonObjectDict.ContainsKey(Arg.Any <string>()).Returns(true);
            var target = JsonObjectValue.FromDictionary(jsonObjectDict);

            // when
            var obtained = target.ContainsKey("foo");

            // then
            Assert.That(obtained, Is.True);
            _ = jsonObjectDict.Received(1).ContainsKey("foo");

            // and when
            obtained = target.ContainsKey("bar");

            // then
            Assert.That(obtained, Is.True);
            _ = jsonObjectDict.Received(1).ContainsKey("bar");
        }
Ejemplo n.º 22
0
            public void Should_Register_The_Context()
            {
                // Given
                var services = Substitute.For <ICakeServices>();
                var builder  = Substitute.For <ICakeRegistrationBuilder>();

                services.RegisterType(Arg.Any <Type>()).Returns(builder); // Return a builder object when registering
                builder.AsSelf().Returns(builder);                        // Return same builder object when chaining
                builder.As(Arg.Any <Type>()).Returns(builder);            // Return same builder object when chaining

                // When
                services.UseContext <FrostingContext>();

                // Then
                Received.InOrder(() =>
                {
                    services.RegisterType <FrostingContext>();
                    builder.AsSelf();
                    builder.As <IFrostingContext>();
                    builder.Singleton();
                });
            }
Ejemplo n.º 23
0
        public void SleepTimeIsDoubledAndResetAfterSuccess()
        {
            httpClient.SendTimeSyncRequest().Returns(
                // request 1 fails 2 times
                x => null,
                x => null,
                x => null,
                x => null,
                x => null,
                x => CreateValidTimeResponse(currentTime, 10),
                // request 2 fails 1 time
                x => null,
                // other requets do not fail
                x => CreateValidTimeResponse(currentTime, 10),
                x => CreateValidTimeResponse(currentTime, 10),
                x => CreateValidTimeResponse(currentTime, 10),
                x => CreateValidTimeResponse(currentTime, 10)
                );

            // when
            var target = new BeaconSendingTimeSyncState();

            target.Execute(context);

            // then
            httpClient.Received(11).SendTimeSyncRequest();
            context.Received(6).Sleep(Arg.Any <int>());
            Received.InOrder(() =>
            {
                // sleeps for first request
                context.Sleep(1000);  // start with 1 sec
                context.Sleep(2000);  // double
                context.Sleep(4000);  // double
                context.Sleep(8000);  // double
                context.Sleep(16000); // double
                // sleeps for second request
                context.Sleep(1000);  // start with 1 sec again
            });
        }
Ejemplo n.º 24
0
        public async void GetUser_CalledWithValidId_ReturnsOkWithUser()
        {
            IUnitOfWork       _unitOfWork    = Substitute.For <IUnitOfWork>();
            ICookieManager    _cookieManager = Substitute.For <ICookieManager>();
            IUserStore <User> _usersStore    = Substitute.For <IUserStore <User> >();

            var  Id   = "1";
            User user = new User {
                Id = Id
            };

            _unitOfWork.Users.Get(Arg.Any <Expression <Func <User, bool> > >()).Returns(user);

            var usersController = new UsersController(_unitOfWork, new UserManager <User>(_usersStore, null, null, null, null, null, null, null, null), _cookieManager);

            var result = await usersController.GetUser(Id);

            var okObjectResult = Assert.IsType <OkObjectResult>(result);
            var returnValue    = Assert.IsType <User>(okObjectResult.Value);

            Assert.Equal(Id, returnValue.Id);
        }
Ejemplo n.º 25
0
        private IInteractionInvoker BuildInvoker(string fileName)
        {
            var invoker = Substitute.For <IInteractionInvoker>();

            invoker.When(x => x.Invoke(Arg.Any <SaveFileInteraction>())).Do(info =>
            {
                var interaction      = info.Arg <SaveFileInteraction>();
                interaction.FileName = fileName;
                interaction.Success  = true;
            });

            invoker.When(x => x.Invoke(Arg.Any <OpenFileInteraction>())).Do(info =>
            {
                var interaction      = info.Arg <OpenFileInteraction>();
                interaction.FileName = fileName;
                interaction.Success  = true;
            });

            invoker.When(x => x.Invoke(Arg.Any <MessageInteraction>())).Do(info => info.Arg <MessageInteraction>().Response = MessageResponse.Yes);

            return(invoker);
        }
Ejemplo n.º 26
0
        public async void GetRole_CalledWithValidId_ReturnsOkWithUserRole()
        {
            IUnitOfWork       _unitOfWork    = Substitute.For <IUnitOfWork>();
            ICookieManager    _cookieManager = Substitute.For <ICookieManager>();
            IUserStore <User> _usersStore    = Substitute.For <IUserStore <User> >();

            var testId = "1";
            var role   = "Student";

            _unitOfWork.Users.Get(Arg.Any <Expression <Func <User, bool> > >()).Returns(new User {
                Role = role
            });

            var usersController = new UsersController(_unitOfWork, new UserManager <User>(_usersStore, null, null, null, null, null, null, null, null), _cookieManager);

            var result = await usersController.GetRole(testId);

            var okObjectResult = Assert.IsType <OkObjectResult>(result);
            var returnValue    = Assert.IsType <string>(okObjectResult.Value);

            Assert.Equal(role, returnValue);
        }
Ejemplo n.º 27
0
        public void DeletesLockIfOwnedBySomeoneElseAndLockHasTimedOut()
        {
            var lockIo        = Substitute.For <ILockIo>();
            var name          = Guid.NewGuid().ToString();
            var processFinder = Substitute.For <IProcessFinder>();

            processFinder.ProcessIsRunning(Arg.Any <int>(), Arg.Any <string>()).Returns(true);
            var semaphore = new LockFileBasedSemaphore(name, TimeSpan.FromSeconds(30), lockIo, processFinder);
            //not setting processid/threadid, therefore its someone elses
            var fileLock = new FileLock {
                Timestamp = (DateTime.Now.Subtract(TimeSpan.FromMinutes(5))).Ticks
            };

            lockIo.ReadLock(Arg.Any <string>()).Returns(fileLock);
            lockIo.LockExists(Arg.Any <string>()).Returns(true);
            lockIo.WriteLock(Arg.Any <string>(), Arg.Any <FileLock>()).Returns(true);
            var result = semaphore.TryAcquireLock();

            Assert.That(result, Is.True);
            lockIo.Received().DeleteLock(Arg.Any <string>());
            lockIo.Received().WriteLock(Arg.Any <string>(), Arg.Any <FileLock>());
        }
Ejemplo n.º 28
0
        public async Task ProcessPostActionShouldSucceed()
        {
            // Arrange
            var settings = new ProcessHttpSettings
            {
                Uri     = new Uri("https://blip.ai"),
                Method  = HttpMethod.Post.ToString(),
                Body    = "{\"plan\":\"Premium\",\"details\":{\"address\": \"Rua X\"}}",
                Headers = new Dictionary <string, string>()
                {
                    { "Content-Type", "application/json" },
                    { "Authorization", "Key askçjdhaklsdghasklgdasd=" }
                },
                ResponseBodyVariable   = "httpResultBody",
                ResponseStatusVariable = "httpResultStatus",
            };

            var target = GetTarget();

            var httpResponseMessage = new HttpResponseMessage()
            {
                StatusCode = HttpStatusCode.Accepted,
                Content    = new StringContent("Some result")
            };

            HttpClient.SendAsync(Arg.Any <HttpRequestMessage>(), Arg.Any <CancellationToken>()).Returns(httpResponseMessage);

            // Act
            await target.ExecuteAsync(Context, JObject.FromObject(settings), CancellationToken);

            // Assert
            await HttpClient.Received(1).SendAsync(
                Arg.Is <HttpRequestMessage>(
                    h => h.RequestUri.Equals(settings.Uri)), Arg.Any <CancellationToken>());

            await Context.Received(1).SetVariableAsync(settings.ResponseStatusVariable, ((int)HttpStatusCode.Accepted).ToString(), Arg.Any <CancellationToken>());

            await Context.Received(1).SetVariableAsync(settings.ResponseBodyVariable, "Some result", Arg.Any <CancellationToken>());
        }
        public void can_provide_custom_locator_holiday_dayOfWeek_strategy()
        {
            var mockHolidayStrategy = Substitute.For <IHolidayStrategy>();

            mockHolidayStrategy.IsHoliDay(Arg.Any <DateTime>()).Returns(true);
            var mockDayOfWeekStartegy = Substitute.For <IWorkingDayOfWeekStrategy>();

            mockDayOfWeekStartegy.IsWorkingDay(Arg.Any <DayOfWeek>()).Returns(true);

            WorkingDayCultureInfo workingdayCultureInfo = new WorkingDayCultureInfo()
            {
                LocateHolidayStrategy          = (n) => { return(mockHolidayStrategy); },
                LocateWorkingDayOfWeekStrategy = (n) => { return(mockDayOfWeekStartegy); }
            };

            DateTime marchFirst = new DateTime(1991, 3, 1);

            Assert.IsTrue(marchFirst.IsHoliday(workingdayCultureInfo));
            Assert.IsFalse(marchFirst.IsWorkingDay(workingdayCultureInfo));
            mockHolidayStrategy.Received().IsHoliDay(marchFirst);
            mockDayOfWeekStartegy.Received().IsWorkingDay(marchFirst.DayOfWeek);
        }
Ejemplo n.º 30
0
        public async Task ProcessPostActionWithoutValidSettingsShouldFailed()
        {
            // Arrange
            var settings = new ProcessHttpSettings
            {
                Method  = HttpMethod.Post.ToString(),
                Body    = "{\"plan\":\"Premium\",\"details\":{\"address\": \"Rua X\"}}",
                Headers = new Dictionary <string, string>()
                {
                    { "Content-Type", "application/json" },
                    { "Authorization", "Key askçjdhaklsdghasklgdasd=" }
                },
            };

            var target = GetTarget();

            var httpResponseMessage = new HttpResponseMessage()
            {
                StatusCode = HttpStatusCode.InternalServerError,
                Content    = new StringContent("Error")
            };

            HttpClient.SendAsync(Arg.Any <HttpRequestMessage>(), Arg.Any <CancellationToken>()).Returns(httpResponseMessage);

            // Act
            try
            {
                await target.ExecuteAsync(Context, JObject.FromObject(settings), CancellationToken);

                throw new Exception();
            }
            catch (ValidationException exception)
            {
                // Assert
                await HttpClient.DidNotReceive().SendAsync(
                    Arg.Is <HttpRequestMessage>(
                        h => h.RequestUri.Equals(settings.Uri)), Arg.Any <CancellationToken>());
            }
        }