public async Task should_set_channel_topic()
{
// given
const string slackKey = "I-is-another-key";
const string channelName = "my-channel";
const string channelTopic = "my topic";
var expectedResponse = new TopicResponse()
{
Topic = channelTopic
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.SetTopic(slackKey, channelName, channelTopic);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.CHANNEL_SET_TOPIC_PATH))
.WithQueryParamValue("token", slackKey)
.WithQueryParamValue("channel", channelName)
.WithQueryParamValue("topic", channelTopic)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Topic);
}
public async Task should_call_expected_url_and_return_expected_groups()
{
// given
const string slackKey = "I-is-another-key";
var expectedResponse = new GroupsResponse
{
Groups = new[]
{
new Group {
IsGroup = true, Name = "name1"
},
new Group {
IsOpen = true, Name = "name2"
}
}
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.GetGroups(slackKey);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.GROUPS_LIST_PATH))
.WithQueryParamValue("token", slackKey)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Groups);
}
public async Task should_call_expected_url_with_given_slack_key()
{
// given
const string slackKey = "I-is-da-key-yeah";
var expectedResponse = new HandshakeResponse
{
Ok = true,
WebSocketUrl = "some-url"
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _handshakeClient.FirmShake(slackKey);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)));
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlHandshakeClient.HANDSHAKE_PATH))
.WithQueryParamValue("token", slackKey)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse);
}
public async Task should_call_expected_url_and_return_expected_users()
{
// given
const string slackKey = "I-is-another-key";
var expectedResponse = new UsersResponse
{
Members = new[]
{
new User {
Id = "some-id-thing", IsBot = true
},
new User {
Name = "some-id-thing", Deleted = true
},
}
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.GetUsers(slackKey);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.USERS_LIST_PATH))
.WithQueryParamValue("token", slackKey)
.WithQueryParamValue("presence", "1")
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Members);
}
internal override XElement CreateXml()
{
XmlParserTempProjectHelper.Sprite = this;
var xRoot = new XElement(XmlConstants.Object);
xRoot.SetAttributeValue(XmlConstants.Name, Name.ToString());
if (Looks != null)
{
xRoot.Add(Looks.CreateXml());
}
//xRoot.Add(new XElement("name")
//{
// Value = Name
//});
//if (Scripts != null)
//{
// xRoot.Add(Scripts.CreateXml());
//}
if (Sounds != null)
{
xRoot.Add(Sounds.CreateXml());
}
if (Scripts != null)
{
xRoot.Add(Scripts.CreateXml());
}
return(xRoot);
}
public async Task should_join_direct_message_channel()
{
// given
const string slackKey = "I-is-another-key";
const string userId = "blahdy-blah";
var expectedResponse = new JoinChannelResponse
{
Channel = new Channel
{
Id = "some-channel",
IsChannel = true
}
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.JoinDirectMessageChannel(slackKey, userId);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.JOIN_DM_PATH))
.WithQueryParamValue("token", slackKey)
.WithQueryParamValue("user", userId)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Channel);
}
public async Task should_call_expected_url_and_return_expected_channels()
{
// given
const string slackKey = "I-is-da-key-yeah";
var expectedResponse = new ChannelsResponse
{
Channels = new[]
{
new Channel {
IsChannel = true, Name = "name1"
},
new Channel {
IsArchived = true, Name = "name2"
},
}
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.GetChannels(slackKey);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.CHANNELS_LIST_PATH))
.WithQueryParamValue("token", slackKey)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Channels);
}
public async Task should_call_expected_url_with_given_slack_key()
{
// given
const string slackKey = "something-that-looks-like-a-slack-key";
const string channel = "channel-name";
const string text = "some-text-for-you";
var expectedResponse = new StandardResponse();
_httpTest.RespondWithJson(expectedResponse);
// when
await _chatClient.PostMessage(slackKey, channel, text, null);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)));
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChatClient.SEND_MESSAGE_PATH))
.WithQueryParamValue("token", slackKey)
.WithQueryParamValue("channel", channel)
.WithQueryParamValue("text", text)
.WithQueryParamValue("as_user", "true")
.WithoutQueryParam("attachments")
.Times(1);
}
public async Task should_create_channel()
{
// given
const string slackKey = "I-is-another-key";
const string channelName = "my-channel";
var expectedResponse = new ChannelResponse()
{
Channel = new Channel
{
Id = "some-channel",
IsChannel = true
}
};
_httpTest.RespondWithJson(expectedResponse);
// when
var result = await _channelClient.CreateChannel(slackKey, channelName);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)), Times.Once);
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChannelClient.CHANNEL_CREATE_PATH))
.WithQueryParamValue("token", slackKey)
.WithQueryParamValue("name", channelName)
.Times(1);
result.ToExpectedObject().ShouldEqual(expectedResponse.Channel);
}
public async Task should_call_expected_url_with_given_slack_key()
{
// given
const string slackKey = "something-that-looks-like-a-slack-key";
const string channel = "channel-name";
const string text = "some-text-for-you";
var expectedResponse = new DefaultStandardResponse();
_httpTest.RespondWithJson(expectedResponse);
// when
await _chatClient.PostMessage(slackKey, channel, text, null);
// then
_responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)));
_httpTest
.ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlChatClient.SEND_MESSAGE_PATH))
.WithRequestUrlEncoded(new
{
token = slackKey,
channel = channel,
text = text,
as_user = "******",
link_names = "true"
})
.Times(1);
}
public void then_it_should_save_a_new_ticket_to_the_repo()
{
GetMockFor <IRepository <Ticket> >()
.Verify(r => r.Add(Looks.LikePartialOf <Ticket>(new
{
SubmittedBy = "*****@*****.**",
Subject = "Test ticket!",
Body = "Test body!"
})));
}
public void moq_will_match_on_a_partial_object()
{
var mock = GetMockFor <ITestService>();
mock.Object.DoStuff(new TestObject {
ID = 1, Name = "Test"
});
Assert.DoesNotThrow(() => mock.Verify(s => s.DoStuff(Looks.LikePartialOf <TestObject>(new { ID = 1, Name = "Test" }))));
}
public void moq_will_not_match_on_a_nonequivalent_partial_object()
{
var mock = GetMockFor <ITestService>();
mock.Object.DoStuff(new TestObject {
ID = 3, Name = "Name"
});
Assert.Throws <MockException>(() => mock.Verify(s => s.DoStuff(Looks.LikePartialOf <TestObject>(new { ID = 1, Name = "Not Name" }))));
}
public void CanChooseWork()
{
var programmer = Create.Programmer.WithSkill("A").Please;
var team = Create.Team.With(programmer);
var backlog = Create.Backlog.WithItem("US1", "A", "B");
var teamWorkStrategy = new IgnoreBacklogOrderTeamWorkStrategy();
teamWorkStrategy.DistributeWork(backlog, team);
Assert.That(programmer.WorkItem, Looks.LikeWorkItem("US1.A"));
}
public void moq_will_not_match_on_a_strongly_typed_partial_object_that_differs()
{
var mock = GetMockFor <ITestService>();
mock.Object.DoStuff(new TestObject {
ID = 1, Name = "Test"
});
Assert.Throws <MockException>(() => mock.Verify(s => s.DoStuff(Looks.Like(() => new TestObject {
ID = 2
}))));
}
public void then_it_will_match_on_a_strongly_typed_partial_object_with_a_matching_expression()
{
var mock = GetMockFor <ITestService>();
mock.Object.DoStuff(new TestObject {
ID = 1, Name = "Test"
});
Assert.DoesNotThrow(() => mock.Verify(s => s.DoStuff(Looks.Like(() => new TestObject {
ID = Some.ValueOf <int>(x => x == 1)
}))));
}
public void then_it_will_not_match_on_a_strongly_typed_partial_object_with_a_partial_matcher_that_should_not_match()
{
var mock = GetMockFor <ITestService>();
mock.Object.DoStuff(new TestObject {
ID = 1, Name = "Test"
});
Assert.Throws <MockException>(() => mock.Verify(s => s.DoStuff(Looks.Like(() => new TestObject {
ID = Some.ValueOf <int>(x => x == 2)
}))));
}
public void OneBacklogItem_OneComponent_OneProgrammer()
{
var team = Create.Team.WithProgrammer("Homer", "A");
var backlog = Create.Backlog
.WithItem("US1", "A");
var schedule = new Schedule(backlog, team);
Assert.That(schedule.AsString(), Looks.LikeSchedule(@"
| | Homer |
| 1 | US1.A |"));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var style = Looks != ButtonStyle.@default ? "--" + Looks.ToString().ToLower() : "";
var size = Size != ButtonSize.@default ? "--" + Size.ToString().ToLower() : "";
var color = Color != Color.@default ? "--" + Color.ToString().ToLower() : "";
output.Attributes.Merge("class", $"{ElementName} {style} {size} {color}");
if (output.Attributes.TryGetAttribute("is", out var attr))
{
output.Attributes.Remove(attr);
}
}
public void then_it_publishes_an_event()
{
GetMockFor <IPublisher>()
.Verify(p => p.Publish(Looks.Like(new InvoiceSubmittedEvent
{
BillingName = _invoice.BillingName,
BillingAddress = _invoice.BillingAddress,
BillingCity = _invoice.BillingCity,
BillingZip = _invoice.BillingZip,
Amount = _invoice.Amount,
Description = _invoice.Description
})));
}
public void SecondWorkDistribution_DistributesSecondWorkItem()
{
var homer = Create.Programmer.WithSkill("A").Please;
var team = Create.Team.With(homer).Please;
var backlog = Create.Backlog
.WithItem("US1", "A")
.WithItem("US2", "A");
team.DistributeWork(backlog);
team.DistributeWork(backlog);
Assert.That(homer.WorkItem, Looks.LikeWorkItem("US2.A"));
}
public void When2ProgrammersDo1PBI_Programmer2HasDoesNothing()
{
var programmer1 = Create.Programmer.WithSkill("A").Please;
var programmer2 = Create.Programmer.WithSkill("A").Please;
var team = Create.Team.With(programmer1, programmer2);
var backlog = Create.Backlog.WithItem("US1", "A");
var teamWorkStrategy = new IgnoreBacklogOrderTeamWorkStrategy();
teamWorkStrategy.DistributeWork(backlog, team);
Assert.That(programmer1.WorkItem, Looks.LikeWorkItem("US1.A"));
Assert.False(programmer2.IsWorking);
}
public void TShapedTeam_CanWorkOnMultipleComponents()
{
var homer = Create.Programmer.WithSkills("A", "B").Please;
var marge = Create.Programmer.WithSkills("A", "B").Please;
var team = Create.Team.With(homer, marge).Please;
var backlog = Create.Backlog
.WithItem("US1", "A", "B");
team.DistributeWork(backlog);
Assert.That(homer.WorkItem, Looks.LikeWorkItem("US1.A"));
Assert.That(marge.WorkItem, Looks.LikeWorkItem("US1.B"));
}
public void TeamCanDistributeWorkAcrossProgrammersForDay()
{
var programmerA = Create.Programmer.WithSkill("A").Please;
var programmerB = Create.Programmer.WithSkill("B").Please;
var team = Create.Team.With(programmerA, programmerB).Please;
var backlog = Create.Backlog
.WithItem("US1", "A", "B");
team.DistributeWork(backlog);
Assert.That(programmerA.WorkItem, Looks.LikeWorkItem("US1.A"));
Assert.That(programmerB.WorkItem, Looks.LikeWorkItem("US1.B"));
}
public void OneBacklogItem_TwoComponents_TwoProgrammers()
{
var team = Create.Team
.WithProgrammer("Homer", "A")
.WithProgrammer("Marge", "B");
var backlog = Create.Backlog
.WithItem("US1", "A", "B");
var schedule = new Schedule(backlog, team);
Assert.That(schedule.AsString(), Looks.LikeSchedule(@"
| | Homer | Marge |
| 1 | US1.A | US1.B |"));
}
public void then_it_verifies_correctly_if_the_object_matches_the_specified_properties()
{
var myCar = new TrainCar {
Name = "Simple Car", MaxPassengers = 100, YearBuilt = 2014
};
GetMockFor <ITrainYard>().Object
.StoreCar(myCar);
GetMockFor <ITrainYard>()
.Verify(x => x.StoreCar(Looks.Like(() => new TrainCar {
YearBuilt = 2014
})));
}
public static void Main(string[] args)
{
// Es muss Datenbank sowie Unit-Tests da sein
Console.WriteLine("Hello World!");
Console.WriteLine(addTwoNumbers(2, 4));
Character cronos = new Character(19, 15, 17, 10, 12, 11, "Roy Greenhilt", "Christoph");
Console.WriteLine(returnModifiers(cronos.Str));
Console.WriteLine(cronos.CarryingCapacity);
Console.WriteLine(cronos.Prof);
Looks l1 = new Looks();
Console.WriteLine(l1.HowDoILook("gnome"));
}
public void RespectWipLimit()
{
var homer = Create.Programmer.WithSkill("A").Please;
var marge = Create.Programmer.WithSkill("B").Please;
var team = Create.Team.With(homer, marge);
var backlog = Create.Backlog
.WithItem("US1", "A")
.WithItem("US2", "B");
var teamWorkStrategy = new RespectWipLimitIgnoreBacklogOrderTeamWorkStrategy(wipLimit: 1);
teamWorkStrategy.DistributeWork(backlog, team);
Assert.That(homer.WorkItem, Looks.LikeWorkItem("US1.A"));
Assert.False(marge.IsWorking);
}
private void Subscribe()
{
MessagingCenter.Subscribe <HarderobePageItemVM>(this, "NewImage", (sender) => {
if (Looks.Contains(Looks.Last()))
{
Looks.Remove(Looks.Last());
Looks.Add(new ListLooksVM(new LooksItemDTO
{
LooksId = 0,
LooksTitle = "New",
LooksSource = sender.DTO.LooksSource
}));
}
});
}
public void TeamRespectingWipLimit_ForUserStory()
{
var team = Create.Team
.WithRespectWipLimitIgnoreBacklogOrderTeamWorkStrategy(1)
.WithProgrammer("Homer", "A")
.WithProgrammer("Marge", "A");
var backlog = Create.Backlog
.WithItem("US1", "A", "A");
var schedule = new Schedule(backlog, team);
Assert.That(schedule.AsString(), Looks.LikeSchedule(@"
| | Homer | Marge |
| 1 | US1.A | US1.A |"));
}
