예제 #1
0
        public async Task CanCrudStoriesAndFeatures()
        {
            // Given CRUD client
            var client = new LeanwareTestClient(_factory);

            // When I create new feature
            var createFeatureResult = await client.Create <Feature>();

            // Then created feature should have valid ID and title
            var createdFeature = createFeatureResult.Received;

            createdFeature.Id.Should().BeGreaterThan(0);
            createdFeature.Status.Should().Be("New");
            createdFeature.Title.Should().Be(createFeatureResult.Sent.Title);

            // When I update feature
            var featureUpdate = new { Tags = RandomTags };

            // Then updated feature should have new title
            var featureUpdateResult = await client.Update <Feature>(createdFeature.UpdatePath, featureUpdate);

            featureUpdateResult.Received.Title.Should().Be(createdFeature.Title);
            featureUpdateResult.Received.Tags.Should().Contain(featureUpdate.Tags);

            // When I create story
            var createStoryResult = await client.Create <Story>(new { FeatureId = createdFeature.Id });

            // Then I created story should have valid ID and title
            var createdStory = createStoryResult.Received;

            createdStory.Id.Should().BeGreaterThan(0);

            createdStory.Title.Should().Be(createStoryResult.Sent.Title);

            createdStory.Status.Should().Be("New");

            createdStory.FeatureId.Should().Be(createdFeature.Id);

            // When I update story
            var storyUpdate = new { Title = RandomTitle("S") };

            // Then updated story should have new title
            var storyUpdateResult = await client.Update <Story>(createdStory.UpdatePath, storyUpdate);

            storyUpdateResult.Received.Title.Should().Be(storyUpdate.Title);

            // When I delete story
            await client.Delete(createdStory.DeletePath);

            // Then getting story should return 404
            var deletedStory = await client.Get(createdStory.ReadPath);

            deletedStory.StatusCode.Should().Be(HttpStatusCode.NotFound);

            // When I delete feature
            await client.Delete(createdFeature.DeletePath);

            // Then getting feature should return 404
            var deletedFeature = await client.Get(createdFeature.ReadPath);

            deletedFeature.StatusCode.Should().Be(HttpStatusCode.NotFound);
        }
예제 #2
0
        public async Task CanCrudStoriesAndFeatures()
        {
            var client = new LeanwareTestClient(_factory);

            var featureTitle = RandomFeatureTitle;
            var feature      = new
            {
                Id    = 0,
                Title = featureTitle,
                Tags  = RandomFeatureTags
            };

            feature = await client.PostSelf("api/features", feature);

            feature.Id.Should().BeGreaterThan(0);
            feature.Title.Should().Be(featureTitle);

            var featurePath = $"api/features/{feature.Id}";

            var updatedFeature = new
            {
                Title = $"{featureTitle} and {featureTitle}"
            };

            await client.Patch(featurePath, updatedFeature);

            feature = await client.Get(featurePath, feature);

            feature.Title.Should().Be($"{featureTitle} and {featureTitle}");

            var storyTitle = RandomStoryTitle;

            var story = new
            {
                Id          = 0,
                Title       = storyTitle,
                Description = nameof(CanCrudStoriesAndFeatures),
                Tags        = RandomStoryTags,
                FeatureId   = feature.Id
            };

            story = await client.PostSelf("api/stories", story);

            story.Id.Should().BeGreaterThan(0);

            var storyPath = $"api/stories/{story.Id}";

            story.Title.Should().Be(storyTitle);

            var updatedStory = new
            {
                Title = $"{storyTitle} and {storyTitle}"
            };

            await client.Patch(storyPath, updatedStory);

            story = await client.Get(storyPath, story);

            story.Title.Should().Be($"{storyTitle} and {storyTitle}");

            await client.Delete(storyPath);

            var deletedStory = await client.Get(storyPath);

            deletedStory.StatusCode.Should().Be(HttpStatusCode.NotFound);

            await client.Delete(featurePath);

            var deletedFeature = await client.Get(featurePath);

            deletedFeature.StatusCode.Should().Be(HttpStatusCode.NotFound);
        }