citrix 0.2.0 → 0.2.1

data/test/citrix/training/helpers/http_client_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class HttpClientTest < Minitest::Test
+  let(:helper) { Object.new.extend(Citrix::Training::Helpers::HttpClient) }
+  let(:config) { helper.http_client.configuration }
+
+  test "returns json parser" do
+    assert_equal Aitch::ResponseParser::JSONParser.engine, helper.json_parser
+  end
+
+  test "returns url" do
+    url = helper.url_for("trainings", 1234)
+    assert_equal File.join(Citrix::Training::API_ENDPOINT, "trainings", "1234"), url
+  end
+
+  test "enabled debug mode" do
+    $DEBUG = true
+    assert_kind_of Logger, config.logger
+  end
+
+  test "skips debug mode" do
+    $DEBUG = false
+    refute config.logger
+  end
+
+  test "sets user agent" do
+    assert_equal "Citrix::Rubygems/#{Citrix::VERSION}", config.user_agent
+  end
+
+  test "sets content type" do
+    assert_equal "application/json", config.default_headers["Content-Type"]
+  end
+
+  test "sets accept" do
+    assert_equal "application/json", config.default_headers["Accept"]
+  end
+
+  test "sets authorization" do
+    credentials = mock(oauth_token: "OAUTH_TOKEN")
+    helper.expects(:credentials).returns(credentials)
+    auth_header = config.default_headers["Authorization"].call
+
+    assert_equal "OAuth oauth_token=OAUTH_TOKEN", auth_header
+  end
+end

data/test/citrix/training/helpers/initializer_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class InitializerTest < Minitest::Test
+  test "assigns properties" do
+    klass = Class.new do
+      include Citrix::Training::Helpers::Initializer
+      attr_accessor :name, :email
+    end
+
+    instance = klass.new(name: "John", email: "john@example.com")
+
+    assert_equal "John", instance.name
+    assert_equal "john@example.com", instance.email
+  end
+end

data/test/citrix/training/namespace/registrants_test.rb

@@ -0,0 +1,95 @@
+require "test_helper"
+
+module RegistrantsTest
+  class NamespaceCreateTest < Minitest::Test
+    let(:client) { build_client }
+    let(:training) { build_training }
+    let(:serializer) { Citrix::Training::Serializer::Registrant }
+
+    test "performs request" do
+      stub_request(:post, /.+/).to_return(
+        body: "{}",
+        headers: {"Content-Type" => "application/json"}
+      )
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings", training.key, "registrants")
+      attrs = build_registrant_attributes
+      serialized_attrs = serialize(attrs)
+      client.registrants(training).create(attrs)
+
+      assert_equal :post, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+      assert_equal JSON.dump(serialized_attrs), last_request.body
+    end
+
+    test "updates registrant with additional attributes" do
+      attrs = JSON.load(fixtures.join("register.json").read)
+
+      stub_request(:post, /.+/).to_return(
+        body: JSON.dump(attrs),
+        headers: {"Content-Type" => "application/json"}
+      )
+
+      response, registrant = client.registrants(training).create({first_name: "John"})
+
+      assert_equal "John", registrant.first_name
+      assert_equal attrs["joinUrl"], registrant.join_url
+      assert_equal attrs["confirmationUrl"], registrant.confirmation_url
+      assert_equal attrs["registrantKey"], registrant.key
+    end
+  end
+
+  class NamespaceAllTest < Minitest::Test
+    let(:client) { build_client }
+    let(:training) { build_training }
+
+    test "performs request" do
+      stub_request(:get, /.+/).to_return(
+        body: "[]",
+        headers: {"Content-Type" => "application/json"}
+      )
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings", training.key, "registrants")
+      client.registrants(training).all
+
+      assert_equal :get, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+    end
+
+    test "returns registrants" do
+      stub_request(:get, /.+/).to_return(
+        status: 200,
+        body: fixtures.join("registrants.json").read,
+        headers: {"Content-Type" => "application/json"}
+      )
+
+      response, registrants = client.registrants(training).all
+
+      assert_equal 3, registrants.size
+      assert_kind_of Citrix::Training::Resource::Registrant, registrants.first
+    end
+  end
+
+  class NamespaceRemoveTest < Minitest::Test
+    let(:client) { build_client }
+    let(:training) { build_training }
+    let(:registrant) { build_registrant }
+
+    test "performs request" do
+      stub_request(:delete, /.+/)
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings", training.key, "registrants", registrant.key)
+      client.registrants(training).remove(registrant)
+
+      assert_equal :delete, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+    end
+
+    test "returns response" do
+      stub_request(:delete, /.+/)
+      response = client.registrants(training).remove(registrant)
+
+      assert_kind_of Aitch::Response, response
+    end
+  end
+end

data/test/citrix/training/namespace/trainings_test.rb

@@ -0,0 +1,111 @@
+require "test_helper"
+
+module TrainingsTest
+  class NamespaceCreateTest < Minitest::Test
+    let(:client) { build_client }
+    let(:serializer) { Citrix::Training::Serializer::Training }
+
+    test "performs request" do
+      stub_request(:post, /.+/)
+        .to_return(body: "[]", headers: {"Content-Type" => "application/json"})
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings")
+      attrs = build_training_attributes
+      serialized_attrs = serialize(attrs)
+      client.trainings.create(attrs)
+
+      assert_equal :post, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+      assert_equal JSON.dump(serialized_attrs), last_request.body
+    end
+
+    test "returns response" do
+      stub_request(:post, /.+/)
+      response, training = client.trainings.create({})
+      assert_kind_of Aitch::Response, response
+    end
+
+    test "returns training instance" do
+      stub_request(:post, /.+/)
+      response, training = client.trainings.create({})
+      assert_kind_of Citrix::Training::Resource::Training, training
+    end
+
+    test "sets training key" do
+      stub_request(:post, /.+/).to_return(body: %["1234"], status: 201)
+      response, training = client.trainings.create({})
+      assert_equal "1234", training.key
+    end
+  end
+
+  class NamespaceAllTest < Minitest::Test
+    let(:client) { build_client }
+
+    test "performs request" do
+      stub_request(:get, /.+/).to_return(body: "[]", headers: {"Content-Type" => "application/json"})
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings")
+      client.trainings.all
+
+      assert_equal :get, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+    end
+
+    test "returns trainings" do
+      stub_request(:get, /.+/)
+        .to_return(status: 200, body: fixtures.join("trainings.json").read, headers: {"Content-Type" => "application/json"})
+
+      response, trainings = client.trainings.all
+
+      assert_equal 1, trainings.size
+      assert_kind_of Citrix::Training::Resource::Training, trainings.first
+    end
+  end
+
+  class NamespaceFindTest < Minitest::Test
+    let(:client) { build_client }
+
+    test "performs request" do
+      stub_request(:get, /.+/)
+        .to_return(status: 200, body: fixtures.join("training.json").read, headers: {"Content-Type" => "application/json"})
+      client.trainings.find("1234")
+
+      url = url_for("organizers", client.credentials.organizer_key, "trainings", "1234")
+
+      assert_equal :get, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+    end
+
+    test "returns training" do
+      stub_request(:get, /.+/)
+        .to_return(status: 200, body: fixtures.join("training.json").read, headers: {"Content-Type" => "application/json"})
+
+      response, training = client.trainings.find("1234")
+
+      assert_kind_of Citrix::Training::Resource::Training, training
+    end
+  end
+
+  class NamespaceRemoveTest < Minitest::Test
+    let(:client) { build_client }
+
+    test "performs request" do
+      stub_request(:delete, /.+/)
+
+      training = build_training
+      url = url_for("organizers", client.credentials.organizer_key, "trainings", training.key)
+      client.trainings.remove(training)
+
+      assert_equal :delete, last_request.method
+      assert_equal url, last_request.uri.normalize.to_s
+    end
+
+    test "returns response" do
+      stub_request(:delete, /.+/)
+      training = build_training
+      response = client.trainings.remove(training)
+
+      assert_kind_of Aitch::Response, response
+    end
+  end
+end

data/test/citrix/training/resource/registrant_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+module RegistrantTest
+  class ResourceTest < Minitest::Test
+    let(:attributes) {
+      JSON.load(fixtures.join("registrant.json").read)
+    }
+
+    test "loads all attributes" do
+      resource = Citrix::Training::Resource::Registrant.new(
+        Citrix::Training::Resource::Registrant.deserialize(attributes)
+      )
+
+      assert_equal "Charley", resource.first_name
+      assert_equal "Waters", resource.last_name
+      assert_equal "c.waters@test.com", resource.email
+      assert_equal "https://global.gototraining.com/join/training/3480581380460709633/107445004", resource.join_url
+      assert_equal "https://attendee.gototraining.com/registration/confirmation.tmpl?registrant=5646167387902096129&training=3480581380460709633", resource.confirmation_url
+      assert_equal "5646167387902096129", resource.key
+      assert_equal "approved", resource.status
+    end
+  end
+end

data/test/citrix/training/resource/training_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+module TrainingTest
+  class ResourceTest < Minitest::Test
+    let(:attributes) {
+      JSON.load(fixtures.join("training.json").read)
+    }
+
+    test "loads all attributes" do
+      resource = Citrix::Training::Resource::Training.new(
+        Citrix::Training::Resource::Training.deserialize(attributes)
+      )
+
+      assert_equal "Intro to HTML, CSS and JavaScript", resource.name
+      assert_equal "Create basic webpages and sites using HTML 5, CSS3 and basic JavaScript.", resource.description
+      assert_equal "America/New_York", resource.timezone
+      assert_equal "8178251407424893697", resource.key
+      assert resource.confirmation_email
+      assert resource.web_registration
+      assert_equal 1, resource.dates.size
+      assert_equal "2014-03-26T15:00:00Z", resource.dates.first.starts_at.iso8601
+      assert_equal "2014-03-26T23:00:00Z", resource.dates.first.ends_at.iso8601
+    end
+  end
+end

data/test/citrix/training/serializer/registrant_test.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+
+module RegistrantTest
+  class SerializerTest < Minitest::Test
+    let(:serializer) { Citrix::Training::Serializer::Registrant }
+
+    test "returns first name" do
+      assert_equal "NAME", serialize(first_name: "NAME")[:givenName]
+    end
+
+    test "returns last name" do
+      assert_equal "NAME", serialize(last_name: "NAME")[:surname]
+    end
+
+    test "returns email" do
+      assert_equal "EMAIL", serialize(email: "EMAIL")[:email]
+    end
+  end
+
+  class DeserializerTest < Minitest::Test
+    let(:serializer) { Citrix::Training::Serializer::Registrant }
+    let(:raw_attrs) { JSON.load(fixtures.join("registrant.json").read) }
+    let(:attrs) { deserialize(raw_attrs) }
+
+    test "returns first name" do
+      assert_equal raw_attrs["givenName"], attrs[:first_name]
+    end
+
+    test "returns last name" do
+      assert_equal raw_attrs["surname"], attrs[:last_name]
+    end
+
+    test "returns email" do
+      assert_equal raw_attrs["email"], attrs[:email]
+    end
+
+    test "returns join url" do
+      assert_equal raw_attrs["joinUrl"], attrs[:join_url]
+    end
+
+    test "returns confirmation url" do
+      assert_equal raw_attrs["confirmationUrl"], attrs[:confirmation_url]
+    end
+
+    test "returns registrant key" do
+      assert_equal raw_attrs["registrantKey"], attrs[:key]
+    end
+
+    test "returns status" do
+      assert_equal raw_attrs["status"].downcase, attrs[:status]
+    end
+  end
+end

data/test/citrix/training/serializer/training_date_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class SerializerTrainingDateTest < Minitest::Test
+  let(:serializer) { Citrix::Training::Serializer::TrainingDate }
+
+  test "returns starting date" do
+    starting = Time.now
+    ending = starting + 3600
+    params = serialize(starts_at: starting, ends_at: ending)
+
+    assert_equal starting.iso8601, params[:startDate]
+  end
+
+  test "returns ending date" do
+    starting = Time.now
+    ending = starting + 3600
+    params = serialize(starts_at: starting, ends_at: ending)
+
+    assert_equal ending.iso8601, params[:endDate]
+  end
+end

data/test/citrix/training/serializer/training_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+module TrainingTest
+  class SerializerTest < Minitest::Test
+    let(:serializer) { Citrix::Training::Serializer::Training }
+
+    test "returns name" do
+      assert_equal "NAME", serialize(name: "NAME")[:name]
+    end
+
+    test "returns description" do
+      assert_equal "DESCRIPTION", serialize(description: "DESCRIPTION")[:description]
+    end
+
+    test "returns time zone" do
+      assert_equal "TZ", serialize(timezone: "TZ")[:timeZone]
+    end
+
+    test "returns registration settings (web registration)" do
+      params = serialize(web_registration: true)
+      assert_equal false, params[:registrationSettings][:disableWebRegistration]
+    end
+
+    test "returns registration settings (confirmation email)" do
+      params = serialize(confirmation_email: true)
+      assert_equal false, params[:registrationSettings][:disableConfirmationEmail]
+    end
+
+    test "returns dates" do
+      date = Citrix::Training::Resource::TrainingDate.new(Time.now, Time.now + 3600)
+      params = serialize(dates: [date])
+
+      assert_equal 1, params[:times].size
+      assert_equal date.starts_at.iso8601, params[:times].first[:startDate]
+      assert_equal date.ends_at.iso8601, params[:times].first[:endDate]
+    end
+  end
+
+  class DeserializerTest < Minitest::Test
+    let(:serializer) { Citrix::Training::Serializer::Training }
+    let(:attrs) {
+      JSON.load(fixtures.join("training.json").read)
+    }
+
+    test "returns name" do
+      assert_equal attrs["name"], deserialize(attrs)[:name]
+    end
+
+    test "returns description" do
+      assert_equal attrs["description"], deserialize(attrs)[:description]
+    end
+
+    test "returns time zone" do
+      assert_equal attrs["timeZone"], deserialize(attrs)[:timezone]
+    end
+
+    test "returns key" do
+      assert_equal attrs["trainingKey"], deserialize(attrs)[:key]
+    end
+
+    test "returns dates" do
+      params = deserialize(attrs)
+
+      starts_at = Time.parse(attrs["times"][0]["startDate"])
+      ends_at = Time.parse(attrs["times"][0]["endDate"])
+
+      assert_equal 1, params[:dates].size
+      assert_equal starts_at.to_i, params[:dates].first.starts_at.to_i
+      assert_equal ends_at.to_i, params[:dates].first.ends_at.to_i
+    end
+
+    test "returns web registration" do
+      params = deserialize(attrs)
+      assert_equal true, params[:web_registration]
+    end
+
+    test "returns confirmation e-mail" do
+      params = deserialize(attrs)
+      assert_equal true, params[:confirmation_email]
+    end
+  end
+end