public async void TestCreateItemByPathFromBranch()
        {
            await this.RemoveTestItemsFromMasterAndWebAsync();

            const string ItemFromBranchName = "Multiple item branch";

            TestEnvironment.Item expectedItem = this.CreateTestItem(ItemFromBranchName);

            var request = ItemWebApiRequestBuilder.CreateItemRequestWithParentPath(this.testData.Items.CreateItemsHere.Path)
                          .BranchId("{14416817-CDED-45AF-99BF-2DE9883B7AC3}")
                          .ItemName(ItemFromBranchName)
                          .Database("master")
                          .Language("en")
                          .Payload(PayloadType.Content)
                          .Build();

            var createResponse = await session.CreateItemAsync(request);

            this.testData.AssertItemsCount(1, createResponse);

            ISitecoreItem resultItem = createResponse[0];

            this.testData.AssertItemsAreEqual(expectedItem, resultItem);


            var readJustCreatedItemRequest = ItemWebApiRequestBuilder.ReadItemsRequestWithId(resultItem.Id)
                                             .Database("master")
                                             .Build();
            var readJustCreatedItemResponse = await this.session.ReadItemAsync(readJustCreatedItemRequest);

            this.testData.AssertItemsCount(1, readJustCreatedItemResponse);
            this.testData.AssertItemsAreEqual(expectedItem, readJustCreatedItemResponse[0]);
        }
        private async void GetAndCheckItem(TestEnvironment.Item expectedItem, ISitecoreItem resultItem)
        {
            var readResponse = await this.GetItemById(resultItem.Id);

            this.testData.AssertItemsCount(1, readResponse);
            this.testData.AssertItemsAreEqual(expectedItem, readResponse[0]);
        }
        private ISitecoreItem CheckCreatedItem(ScItemsResponse createResponse, TestEnvironment.Item expectedItem)
        {
            this.testData.AssertItemsCount(1, createResponse);
            ISitecoreItem resultItem = createResponse[0];

            this.testData.AssertItemsAreEqual(expectedItem, resultItem);

            return(resultItem);
        }
        public async void TestGetItemByInternationalPath()
        {
            const string ItemInterationalPath = "/sitecore/content/Home/Android/Static/Japanese/宇都宮/ではまた明日";
            var          response             = await GetItemByPath(ItemInterationalPath);

            var expectedItem = new TestEnvironment.Item {
                DisplayName = "ではまた明日",
                Path        = ItemInterationalPath,
                TemplateId  = testData.Items.Home.TemplateId
            };

            testData.AssertItemsAreEqual(expectedItem, response[0]);
        }
Beispiel #5
0
        public async void TestGetItemByPathForTwoItemsWithTheSamePathExist()
        {
            var response = await GetItemByPath(ItemWithSpacesPath);

            testData.AssertItemsCount(1, response);
            var expectedItem = new TestEnvironment.Item
            {
                DisplayName = ItemWithSpacesName,
                Path        = ItemWithSpacesPath,
                Template    = testData.Items.Home.Template
            };

            testData.AssertItemsAreEqual(expectedItem, response[0]);
        }
Beispiel #6
0
        public async void TestGetFieldsWithSymbolsAndSpacesInNameFields()
        {
            var request  = ItemWebApiRequestBuilder.ReadItemsRequestWithId("{00CB2AC4-70DB-482C-85B4-B1F3A4CFE643}").AddFieldsToRead("Normal Text", "__Owner").Build();
            var response = await this.sessionAuthenticatedUser.ReadItemAsync(request);

            testData.AssertItemsCount(1, response);
            var expectedItemTestTemplate = new TestEnvironment.Item
            {
                DisplayName = "Test Fields",
                Template    = "Test Templates/Sample fields"
            };

            testData.AssertItemsAreEqual(expectedItemTestTemplate, response[0]);
            ISitecoreItem item = response[0];

            Assert.AreEqual(2, item.FieldsCount);
            Assert.AreEqual("Normal Text", item["Normal Text"].Name);
            Assert.AreEqual("sitecore\\admin", item["__Owner"].RawValue);
        }
        public async void TestGetFieldsWithSymbolsAndSpacesInNameFields()
        {
            var request = ItemSSCRequestBuilder.ReadItemsRequestWithId("00CB2AC4-70DB-482C-85B4-B1F3A4CFE643")
                          .AddFieldsToRead("Normal Text", "__Owner")
                          .IncludeStandardTemplateFields(true)
                          .Build();

            var response = await this.sessionAuthenticatedUser.ReadItemAsync(request);

            testData.AssertItemsCount(1, response);
            var expectedItemTestTemplate = new TestEnvironment.Item
            {
                DisplayName = "Test Fields",
                TemplateId  = "5FC0D542-E27B-4E55-A1F0-702E959DCD6C"
            };

            testData.AssertItemsAreEqual(expectedItemTestTemplate, response[0]);
            ISitecoreItem item = response[0];

            Assert.AreEqual(11, item.FieldsCount);
            Assert.AreEqual("Normal Text", item["Normal Text"].Name);
            Assert.AreEqual("sitecore\\admin", item["__Owner"].RawValue);
        }
Beispiel #8
0
        public async void TestGetSeveralItemsByQueryWithContentFields()
        {
            var request = ItemWebApiRequestBuilder.ReadItemsRequestWithSitecoreQuery(testData.Items.Home.Path + "/*")
                          .Payload(PayloadType.Content)
                          .Build();
            var response = await this.sessionAuthenticatedUser.ReadItemAsync(request);

            testData.AssertItemsCount(4, response);

            var expectedAllowedParentItem = new TestEnvironment.Item
            {
                DisplayName = "Allowed_Parent",
                Template    = "Sample/Sample Item"
            };
            ISitecoreItem actualAllowedParentItem = response[0];

            testData.AssertItemsAreEqual(expectedAllowedParentItem, actualAllowedParentItem);

            Assert.AreEqual(2, actualAllowedParentItem.FieldsCount);
            Assert.AreEqual("Allowed_Parent", actualAllowedParentItem["Title"].RawValue);


            var expectedTestFieldsItem = new TestEnvironment.Item
            {
                DisplayName = "Test Fields",
                Template    = "Test Templates/Sample fields"
            };

            ISitecoreItem actualTestFieldsItem = response[3];

            testData.AssertItemsAreEqual(expectedTestFieldsItem, actualTestFieldsItem);

            Assert.AreEqual(19, actualTestFieldsItem.FieldsCount);
            Assert.AreEqual("Text", actualTestFieldsItem["Text"].RawValue);
            Assert.AreEqual("1", actualTestFieldsItem["CheckBoxField"].RawValue);
            Assert.AreEqual("Normal Text", actualTestFieldsItem["Normal Text"].RawValue);
        }
Beispiel #9
0
        public async void TestGetItemWithCoreDbLanguageAndVersion()
        {
            const string Db = "CoRE";

            using
            (
                var session = this.CreateAdminSession()
            )
            {
                var response = await this.GetHomeItem(session, Db);

                testData.AssertItemsCount(1, response);
                ISitecoreItem resultItem   = response[0];
                var           expectedItem = new TestEnvironment.Item
                {
                    DisplayName = this.testData.Items.Home.DisplayName,
                    Id          = this.testData.Items.Home.Id,
                    Path        = this.testData.Items.Home.Path,
                    TemplateId  = this.testData.Items.Home.TemplateId
                };
                testData.AssertItemsAreEqual(expectedItem, resultItem);
                Assert.AreEqual("Welcome to Sitecore", resultItem["Title"].RawValue);
            }
        }
    public async void TestGetFieldsWithSymbolsAndSpacesInNameFields()
    {
      var request = ItemWebApiRequestBuilder.ReadItemsRequestWithId("{00CB2AC4-70DB-482C-85B4-B1F3A4CFE643}").AddFieldsToRead("Normal Text", "__Owner").Build();
      var response = await this.sessionAuthenticatedUser.ReadItemAsync(request);

      testData.AssertItemsCount(1, response);
      var expectedItemTestTemplate = new TestEnvironment.Item
      {
        DisplayName = "Test Fields",
        Template = "Test Templates/Sample fields"
      };
      testData.AssertItemsAreEqual(expectedItemTestTemplate, response[0]);
      ISitecoreItem item = response[0];

      Assert.AreEqual(2, item.FieldsCount);
      Assert.AreEqual("Normal Text", item["Normal Text"].Name);
      Assert.AreEqual("sitecore\\admin", item["__Owner"].RawValue);
    }
    public async void TestGetSeveralItemsByQueryWithContentFields()
    {
      var request = ItemWebApiRequestBuilder.ReadItemsRequestWithSitecoreQuery(testData.Items.Home.Path + "/*")
        .Payload(PayloadType.Content)
        .Build();
      var response = await this.sessionAuthenticatedUser.ReadItemAsync(request);

      testData.AssertItemsCount(4, response);

      var expectedAllowedParentItem = new TestEnvironment.Item
      {
        DisplayName = "Allowed_Parent",
        Template = "Sample/Sample Item"
      };
      ISitecoreItem actualAllowedParentItem = response[0];
      testData.AssertItemsAreEqual(expectedAllowedParentItem, actualAllowedParentItem);

      Assert.AreEqual(2, actualAllowedParentItem.FieldsCount);
      Assert.AreEqual("Allowed_Parent", actualAllowedParentItem["Title"].RawValue);


      var expectedTestFieldsItem = new TestEnvironment.Item
      {
        DisplayName = "Test Fields",
        Template = "Test Templates/Sample fields"
      };

      ISitecoreItem actualTestFieldsItem = response[3];
      testData.AssertItemsAreEqual(expectedTestFieldsItem, actualTestFieldsItem);

      Assert.AreEqual(19, actualTestFieldsItem.FieldsCount);
      Assert.AreEqual("Text", actualTestFieldsItem["Text"].RawValue);
      Assert.AreEqual("1", actualTestFieldsItem["CheckBoxField"].RawValue);
      Assert.AreEqual("Normal Text", actualTestFieldsItem["Normal Text"].RawValue);
    }
 public async void TestGetItemByInternationalPath()
 {
   const string ItemInterationalPath = "/sitecore/content/Home/Android/Static/Japanese/宇都宮/ではまた明日";
   var response = await GetItemByPath(ItemInterationalPath);
   var expectedItem = new TestEnvironment.Item
   {
     DisplayName = "ではまた明日",
     Path = ItemInterationalPath,
     Template = testData.Items.Home.Template
   };
   testData.AssertItemsAreEqual(expectedItem, response[0]);
 }
    public async void TestGetItemByPathForTwoItemsWithTheSamePathExist()
    {
      var response = await GetItemByPath(ItemWithSpacesPath);

      testData.AssertItemsCount(1, response);
      var expectedItem = new TestEnvironment.Item
      {
        DisplayName = ItemWithSpacesName,
        Path = ItemWithSpacesPath,
        Template = testData.Items.Home.Template
      };
      testData.AssertItemsAreEqual(expectedItem, response[0]);

    }
    public async void TestGetItemWithCoreDbLanguageAndVersion()
    {
      const string Db = "CoRE";
      using
      (
        var session = this.CreateAdminSession()
      )
      {
        var response = await this.GetHomeItem(session, Db);

        testData.AssertItemsCount(1, response);
        ISitecoreItem resultItem = response[0];
        var expectedItem = new TestEnvironment.Item
        {
          DisplayName = this.testData.Items.Home.DisplayName,
          Id = this.testData.Items.Home.Id,
          Path = this.testData.Items.Home.Path,
          Template = "Sitecore Client/Home"
        };
        testData.AssertItemsAreEqual(expectedItem, resultItem);
        Assert.AreEqual("Welcome to Sitecore", resultItem["Title"].RawValue);
      }
    }