public void TestCopying()
        {
            var origNull = new AgentField(null);

            origNull.SetValue("One", 1);
            var copyNull = new AgentField("Foo"); // Different default!

            copyNull.SetValue(origNull);

            copyNull.GetValue().Should().Be("One");
            copyNull.GetConfidence().Should().Be(1);
            copyNull.Reset();
            copyNull.GetValue().Should().Be("Foo"); // The default should NOT be modified
            copyNull.GetConfidence().Should().Be(-1);


            var origFoo = new AgentField("Foo");

            origFoo.SetValue("Two", 2);
            var copyFoo = new AgentField(null); // Different default!

            copyFoo.SetValue(origFoo);

            copyFoo.GetValue().Should().Be("Two");
            copyFoo.GetConfidence().Should().Be(2);
            copyFoo.Reset();
            copyFoo.GetValue().Should().BeNull(); // The default should NOT be modified
            copyFoo.GetConfidence().Should().Be(-1);
        }
        public void it_returns_the_builds_queued_compatible_agents()
        {
            AgentField            agentField            = AgentField.WithFields(id: true);
            CompatibleAgentsField compatibleAgentsField = CompatibleAgentsField.WithFields(agent: agentField);
            BuildField            buildField            = BuildField.WithFields(compatibleAgents: compatibleAgentsField, id: true);
            BuildsField           buildsField           = BuildsField.WithFields(buildField: buildField);
            var result = m_client.BuildQueue.GetFields(buildsField.ToString()).All();

            Assert.IsNotEmpty(result);
        }
        public void ComparingUserAgents()
        {
            UserAgent baseAgent = new UserAgent("Something 2");
            UserAgent agent0    = new UserAgent("Something 2");
            UserAgent agent1    = new UserAgent("Something 1");
            UserAgent agent2    = new UserAgent("Something 2");
            UserAgent agent3    = new UserAgent("Something 2");
            UserAgent agent4    = new UserAgent("Something 2");

            var field0 = new AgentField("Foo");

            field0.SetValue("One", 1);

            var field1 = new AgentField("Foo");

            field1.SetValue("One", 1);

            var field2 = new AgentField("Foo"); // Same, different value

            field2.SetValue("Two", 1);

            var field3 = new AgentField("Foo"); // Same, different confidence

            field3.SetValue("One", 2);

            var field4 = new AgentField(null); // Same, different default

            field4.SetValue("One", 1);

            // We compare the base agent with 4 variations
            baseAgent.SetImmediateForTesting("Field", field0);
            agent0.SetImmediateForTesting("Field", field1); // Same
            agent1.SetImmediateForTesting("Field", field1); // Different useragent
            agent2.SetImmediateForTesting("Field", field2); // Different field value
            agent3.SetImmediateForTesting("Field", field3); // Different field confidence
            agent4.SetImmediateForTesting("Field", field4); // Different field default value

            // Check em
            baseAgent.Should().BeEquivalentTo(baseAgent);
            baseAgent.Should().BeEquivalentTo(agent0);
            agent0.Should().BeEquivalentTo(baseAgent);
            baseAgent.GetHashCode().Should().Be(agent0.GetHashCode());

            Log.Info(baseAgent.ToString("Field"));


            baseAgent.Equals(agent2).Should().BeFalse();
            baseAgent.Equals(agent3).Should().BeFalse();
            baseAgent.Equals(agent4).Should().BeFalse();

            agent1.Equals("String").Should().BeFalse();
            "String".Equals(agent1).Should().BeFalse();
        }
Beispiel #4
0
        public void it_returns_full_build_field_2()
        {
            var                            tempBuildConfig                = m_client.BuildConfigs.All().First();
            ItemsField                     itemsField                     = ItemsField.WithFields(item: true);
            BuildsField                    buildsField                    = BuildsField.WithFields();
            RelatedField                   relatedField                   = RelatedField.WithFields(builds: buildsField);
            RelatedIssuesField             relatedIssuesField             = RelatedIssuesField.WithFields(href: true);
            ArtifactDependenciesField      artifactDependenciesField      = ArtifactDependenciesField.WithFields();
            BuildArtifactDependenciesField buildArtifactDependenciesField = BuildArtifactDependenciesField.WithFields();
            BuildSnapshotDependenciesField buildSnapshotDependenciesField = BuildSnapshotDependenciesField.WithFields();
            DatasField                     datasField                     = DatasField.WithFields();
            StatisticsField                statisticsField                = StatisticsField.WithFields();
            EntriesField                   entriesField                   = EntriesField.WithFields();
            PropertiesField                propertiesField                = PropertiesField.WithFields();
            ArtifactsField                 artifactsField                 = ArtifactsField.WithFields(href: true);
            ProblemOccurrencesField        problemOccurrences             = ProblemOccurrencesField.WithFields();
            TestOccurrencesField           testOccurrencesField           = TestOccurrencesField.WithFields();
            AgentField                     agentField                     = AgentField.WithFields(id: true);
            CompatibleAgentsField          compatibleAgentsField          = CompatibleAgentsField.WithFields(agent: agentField, href: true);
            BuildField                     buildField1                    = BuildField.WithFields(id: true);
            BuildChangeField               buildChangeField               = BuildChangeField.WithFields(nextBuild: buildField1, prevBuild: buildField1);
            BuildChangesField              buildChangesField              = BuildChangesField.WithFields(buildChange: buildChangeField);
            RevisionField                  revisionField                  = RevisionField.WithFields(version: true);
            RevisionsField                 revisionsField                 = RevisionsField.WithFields();
            LastChangesField               lastChangesField               = LastChangesField.WithFields();
            ChangesField                   changesField                   = ChangesField.WithFields();
            TriggeredField                 triggeredField                 = TriggeredField.WithFields(type: true);
            ProgressInfoField              progressInfoField              = ProgressInfoField.WithFields(currentStageText: true);
            TagsField                      tagsField             = TagsField.WithFields();
            UserField                      userField             = UserField.WithFields(id: true);
            CommentField                   commentField          = CommentField.WithFields(text: true);
            BuildTypeField                 buildTypeField        = BuildTypeField.WithFields(id: true);
            BuildTypeWrapperField          buildTypeWrapperField = BuildTypeWrapperField.WithFields(buildType: buildTypeField);
            LinkField                      linkField             = LinkField.WithFields(type: true);
            LinksField                     linksField            = LinksField.WithFields(link: linkField);
            var                            buildField            = BuildField.WithFields(links: linksField, buildType: buildTypeField, comment: commentField,
                                                                                         tags: tagsField, pinInfo: commentField, user: userField, running_info: progressInfoField,
                                                                                         canceledInfo: commentField, triggered: triggeredField, lastChanges: lastChangesField, changes: changesField,
                                                                                         revisions: revisionsField, versionedSettingsRevision: revisionField,
                                                                                         artifactDependencyChanges: buildChangesField, agent: agentField, compatibleAgents: compatibleAgentsField,
                                                                                         testOccurrences: testOccurrencesField, problemOccurrences: problemOccurrences, artifacts: artifactsField,
                                                                                         properties: propertiesField, resultingProperties: propertiesField, attributes: entriesField,
                                                                                         statistics: statisticsField, metadata: datasField, snapshotDependencies: buildSnapshotDependenciesField,
                                                                                         artifactDependencies: buildArtifactDependenciesField, customArtifactDependencies: artifactDependenciesField,
                                                                                         statusChangeComment: commentField, relatedIssues: relatedIssuesField, replacementIds: itemsField,
                                                                                         related: relatedField);

            var tempBuild = m_client.Builds.LastBuildByBuildConfigId(tempBuildConfig.Id);
            var build     = m_client.Builds.GetFields(buildField.ToString()).ById(tempBuild.Id);

            Assert.IsNotNull(build);
        }