public async Task CreateForThrowsErrorOnNullVenue()
{
var meetup = MeetupClient.WithApiToken("testtoken");
var exception = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Venues.CreateFor("test", null));
Assert.Equal("venue", exception.ParamName);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <TechMeetState> FunctionHandler(TechMeetState input, ILambdaContext context)
{
var apitoken = ApiToken ?? Environment.GetEnvironmentVariable("apitoken");
var meetup = MeetupClient.WithApiToken(apitoken);
var request = new GetEventsRequest(input.GroupName)
{
NoEarlierThan = DateTime.UtcNow.AddMonths(-1),
NoLaterThan = DateTime.UtcNow.AddMonths(2),
Status = EventStatus.Past | EventStatus.Upcoming,
Descending = true
};
var events = await meetup.Events.For(request);
var inputEvents = await input.GetEventsFromS3();
Console.WriteLine($"found {events.Data.Length} events in response");
var finalList = events.Data.Concat(inputEvents).Distinct(new EventEquality()).OrderByDescending(e => DateTime.Parse(e.LocalDate));
inputEvents = finalList.ToList();
await input.SaveEventsToS3(inputEvents);
return(input);
}
public async Task GetThrowsExceptionOnEmptyGroupName()
{
var meetup = MeetupClient.WithApiToken("testToken");
var error = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Groups.Get(string.Empty));
Assert.Equal("groupName", error.ParamName);
}
public async Task FindTopicCategoriesUsesDataCorrectly()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("TopicCategory")
};
var meetup = MeetupClient.WithApiToken("TestToken", options);
var topics = await meetup.Topics.FindCategories();
Assert.NotNull(topics.Data);
Assert.Equal(3, topics.Data.Length);
var topic = topics.Data.Skip(1).First();
Assert.Equal("Tech", topic.Name);
Assert.Equal("tech", topic.ShortName);
Assert.Equal("Tech", topic.SortName);
Assert.Equal(292, topic.Id);
Assert.Single(topic.CategoryIds);
Assert.NotNull(topic.Photo);
Assert.Equal(450131949, topic.Photo.Id);
Assert.Equal(MeetupPhotoType.Event, topic.Photo.Type);
Assert.Equal("https://secure.meetupstatic.com/", topic.Photo.BaseUrl.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/highres_450131949.jpeg", topic.Photo.HighRes.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/600_450131949.jpeg", topic.Photo.Photo.ToString());
Assert.Equal("https://secure.meetupstatic.com/photos/event/2/e/a/d/thumb_450131949.jpeg", topic.Photo.Thumb.ToString());
}
public async Task EventForThrowsOnEmptyName()
{
var meetup = MeetupClient.WithApiToken("testToken");
var exception = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Events.For(string.Empty));
Assert.Equal("groupName", exception.ParamName);
}
public void NullDefaultCreatesDefaults()
{
var meetupclient = new MeetupClient(null);
Assert.NotNull(meetupclient.Options);
Assert.NotNull(meetupclient.Options.CustomSerializer);
Assert.NotNull(meetupclient.Options.Client);
}
public void ValidTokenCreatesClient()
{
var client = MeetupClient.WithApiToken(TestToken);
Assert.NotNull(client.Options.AddedQueryString);
Assert.Equal("true", client.Options.AddedQueryString["sign"]);
Assert.Equal(TestToken, client.Options.AddedQueryString["key"]);
}
public void ValidOAuthTokenCreatesClient()
{
var client = MeetupClient.WithOAuthToken(TestToken);
var header = client.Options.Client.DefaultRequestHeaders.Authorization;
Assert.Equal("Bearer", header.Scheme);
Assert.Equal(TestToken, header.Parameter);
}
public async Task GetWithFieldsGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham?fields=plain_text_no_images_description")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Groups.Get("tech-nottingham", new [] { "plain_text_no_images_description" });
}
public async Task GetGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Groups.Get("tech-nottingham");
}
/// <summary>
/// Get UPS code of enum value
/// </summary>
/// <param name="enumValue">Enum value</param>
/// <returns>UPS code</returns>
public async Task <Event[]> GetEvents()
{
var client = MeetupClient.WithApiToken(_settings.MeetupAuthToken);
var response = await client.Events.For(_settings.MeetupGroupName);
var data = response.Data;
return(data);
}
public async Task FindTopicUsesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topics?photo-host=public&query=tech")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Topics.Find("tech");
}
public async Task RsvpForThrowsOnEmptyNames()
{
var meetup = MeetupClient.WithApiToken("testToken");
var groupNameException = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Rsvps.For(string.Empty, "something"));
Assert.Equal("groupName", groupNameException.ParamName);
var eventIdException = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Rsvps.For("something", string.Empty));
Assert.Equal("eventId", eventIdException.ParamName);
}
public async Task FindTopicThrowsIfQueryIsEmpty()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topics?photo-host=public&query=tech")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Topics.Find(string.Empty));
}
public void CustomSerializerWithOAuthTokenSetCorrectly()
{
var defaults = new MeetupClientOptions
{
CustomSerializer = new JsonSerializer()
};
var meetupClient = MeetupClient.WithOAuthToken(TestToken, defaults);
Assert.Equal(defaults, meetupClient.Options);
}
public async Task FindTopicCategoriesUsesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topic_categories?photo-host=public")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Topics.FindCategories();
}
public async Task ForGroupGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham/venues?fields=taglist")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.For("tech-nottingham");
}
public async Task RecommendedVenueEmptyGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/recommended/venues?fields=taglist")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.Recommended();
}
public async Task <Event> GetEvent(string eventId)
{
var client = MeetupClient.WithApiToken(_settings.MeetupAuthToken);
var response = await client.Events.For(_settings.MeetupGroupName);
var data = response.Data;
var item = data.FirstOrDefault(x => x.Id.Equals(eventId));
return(item);
}
public async Task StatusCreatesCorrectCall()
{
var client = FakeHttpClient.AssertUrl("/status");
var defaults = new MeetupClientOptions
{
Client = client
};
var meetup = new MeetupClient(defaults);
await meetup.Meta.Status();
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="state"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <TechMeetState> FunctionHandler(TechMeetState state, ILambdaContext context)
{
var token = System.Environment.GetEnvironmentVariable("apitoken");
var meetup = MeetupClient.WithApiToken(token);
var group = await meetup.Groups.Get(state.GroupName, new [] { "plain_text_no_images_description" });
await state.SaveFullGroupToS3(group.Data);
return(state);
}
public async Task CreateForGeneratesCorrectUrl()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham/venues?fields=taglist", System.Net.Http.HttpMethod.Post)
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.CreateFor("tech-nottingham", new Venue());
}
public async Task FindVenueOrderedNameGeneratesCorrectUrl()
{
var request = new FindVenuesRequest("rock city");
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/venues?text=rock+city&fields=taglist&order=rating")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.Find("rock city", VenueOrderBy.Rating);
}
public async Task RecommendedTopicThrowsIfGroupsListIsEmpty()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topics?photo-host=public&query=tech")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
var exception = await Assert.ThrowsAsync <ArgumentNullException>(() => meetup.Topics.RecommendedGroupTopic(new int[] {}));
Assert.Equal("basedOnTopics", exception.ParamName);
}
public async Task LocationFindGeneratesCorrectResponse()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("FindLocation")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
var response = await meetup.Geo.FindLocation(string.Empty);
Assert.Equal(5, response.Data.Length);
}
public async Task CreateForGeneratesCorrectBodyContent()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertContent <Venue>(v => {
Assert.NotNull(v);
Assert.Equal("random place", v.Name);
})
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Venues.CreateFor("tech-nottingham", new Venue { Name = "random place" });
}
public async Task StatusDeserialisesCorrectly()
{
var defaults = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("StatusResponse")
};
var meetup = new MeetupClient(defaults);
var meetupResponse = await meetup.Meta.Status();
var statusResponse = meetupResponse.Data;
Assert.Equal("test message", statusResponse.Message);
Assert.Equal("test title", statusResponse.Title);
Assert.Equal(ApiStatus.Unavailable, statusResponse.ApiStatus);
}
public async Task FindTopicCategoriesUsesRequest()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/find/topic_categories?photo-host=public&lat=45.3&lon=-1.18&radius=23.4")
};
var request = new FindTopicCategoriesRequest
{
Latitude = 45.3,
Longitude = -1.18,
MilesRadius = 23.4
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Topics.FindCategories(request);
}
public async Task GetGeneratesCorrectData()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("Group")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
var response = await meetup.Groups.Get("tech-nottingham");
var data = response.Data;
Assert.Equal(14171002, data.Id);
Assert.Equal("Tech Nottingham", data.Name);
Assert.Equal(MeetupVisibility.Public, data.Visibility);
Assert.NotNull(data.Organizer);
Assert.Equal(202648061, data.Organizer.Id);
}
public async Task RsvpParsesDataCorrectly()
{
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertResponse("Rsvps")
};
var meetup = MeetupClient.WithApiToken("testToken", options);
var response = await meetup.Rsvps.For("tech-nottingham", "258091947");
Assert.Single(response.Data);
var rsvpData = response.Data.First();
Assert.Equal("yes", rsvpData.Response);
Assert.Equal("coorganizer", rsvpData.Member.Role);
}
