teamsnap_rb 1.3.3 → 2.0.0.beta

data/spec/teamsnap/item_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "teamsnap"
+
+RSpec.describe "teamsnap__item", :vcr => true do
+  before(:all) do
+    VCR.use_cassette("apiv3-init") do
+      TeamSnap.init(
+        :url => ROOT_TEST_URL,
+        :client_id => "classic",
+        :client_secret => "dont_tell_the_cops"
+      )
+    end
+  end
+
+  describe ".load_items" do
+    it "returns TeamSnap::Object for the given json item" do
+      collection = {
+        :items => [
+          {
+            :href => "http://localhost:3000/teams/10",
+            :data => [
+              {
+                :name => "id",
+                :value => 10
+              },
+              {
+                :name => "type",
+                :value => "team"
+              },
+              {
+                :name => "division_name",
+                :value => nil
+              },
+              {
+                :name => "division_id",
+                :value => nil
+              },
+              {
+                :name => "is_archived_season",
+                :value => false
+              },
+              {
+                :name => "is_retired",
+                :value => false
+              },
+              {
+                :name => "league_name",
+                :value => nil
+              },
+              {
+                :name => "league_url",
+                :value => nil
+              },
+              {
+                :name => "is_in_league",
+                :value => false
+              },
+              {
+                :name => "location_country",
+                :value => "United States"
+              },
+              {
+                :name => "location_postal_code",
+                :value => "80951"
+              },
+              {
+                :name => "location_latitude",
+                :value => nil
+              },
+              {
+                :name => "location_longitude",
+                :value => nil
+              },
+              {
+                :name => "name",
+                :value => "Cheerleading Team"
+              },
+              {
+                :name => "plan_id",
+                :value => 33
+              },
+              {
+                :name => "billed_at",
+                :value => "2016-02-08T00:00:00.000+00:00"
+              },
+              {
+                :name => "season_name",
+                :value => nil
+              },
+              {
+                :name => "sport_id",
+                :value => 31
+              },
+              {
+                :name => "time_zone_description",
+                :value => "Mountain Time (US & Canada)"
+              },
+              {
+                :name => "time_zone_iana_name",
+                :value => "America/Denver"
+              },
+              {
+                :name => "time_zone_offset",
+                :value => "-07:00"
+              },
+              {
+                :name => "updated_at",
+                :value => "2016-02-08T20:04:21Z",
+                :type => "DateTime"
+              },
+              {
+                :name => "created_at",
+                :value => "2016-02-08T20:04:06Z",
+                :type => "DateTime"
+              },
+              {
+                :name => "has_reached_roster_limit",
+                :value => false
+              },
+              {
+                :name => "roster_limit",
+                :value => 4000
+              },
+              {
+                :name => "has_exportable_media",
+                :value => false
+              },
+              {
+                :name => "can_export_media",
+                :value => false
+              },
+              {
+                :name => "last_accessed_at",
+                :value => nil,
+                :type => "DateTime"
+              },
+              {
+                :name => "media_storage_used",
+                :value => 0
+              },
+              {
+                :name => "humanized_media_storage_used",
+                :value => "0 B"
+              }
+            ]
+          }
+        ]
+      }
+
+      expect(
+        TeamSnap::Item.load_items(TeamSnap.root_client, collection)[0].class
+      ).to eq(TeamSnap::Team)
+    end
+  end
+end

data/spec/teamsnap/structure_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "teamsnap"
+
+RSpec.describe "teamsnap__structure", :vcr => true do
+
+  describe ".create_collection_class" do
+    let(:client) {
+      client = TeamSnap::Client.new({
+        :url => ROOT_TEST_URL,
+        :client_id => "classic",
+        :client_secret => "dont_tell_the_cops"
+      })
+    }
+    let(:resp) { TeamSnap.run(client, :get, "/teams", {}) }
+
+    it "registers new classes via introspection of the root collection" do
+      TeamSnap::Structure.send(
+        :create_collection_class,
+        "teams",
+        "http://localhost:3000/teams",
+        resp,
+        nil
+      )
+      expect { TeamSnap::Team }.to_not raise_error
+    end
+
+    it "sets the href attribute on the new class" do
+      TeamSnap::Structure.send(
+        :create_collection_class,
+        "teams",
+        "http://localhost:3000/teams",
+        resp,
+        nil
+      )
+
+      expect(TeamSnap::Team.href).to eq("#{ROOT_TEST_URL}/teams")
+    end
+  end
+
+  describe ".init" do
+    before(:all) do
+      VCR.use_cassette("apiv3-init") do
+        TeamSnap.init(
+          :url => ROOT_TEST_URL,
+          :client_id => "classic",
+          :client_secret => "dont_tell_the_cops"
+        )
+      end
+    end
+
+    it "has all classes in schema loaded except for exceptions list endpoints" do
+      collection = TeamSnap.run(TeamSnap.root_client, :get, "/", {})
+      links = collection.fetch(:links) { [] }
+        .select{|l| !TeamSnap::EXCLUDED_RELS.include?(l[:rel]) }
+
+      links.each do |obj|
+        expect {
+          Object.const_get("TeamSnap::" + Inflecto.classify(obj[:rel]))
+        }.to_not raise_error
+      end
+    end
+  end  
+end

data/spec/teamsnap_spec.rb

@@ -1,12 +1,16 @@
 require "spec_helper"
 require "teamsnap"
 
-RSpec.describe "teamsnap_rb" do
+RSpec.describe "teamsnap_rb", :vcr => true do
   let(:default_url) { TeamSnap::DEFAULT_URL }
   let(:specified_url) { "https://url-fun-zone.com" }
   let(:response) { Typhoeus::Response.new(
-    code: 200, body: { :collection => { :links => [] } }.to_json
+    code: 200,
+    headers: { "content-type" => "application/json" },
+    body: { :collection => { :links => [] } }.to_json
   ) }
+  let(:client_id) { "classic" }
+  let(:client_secret) { "dont_tell_the_cops" }
 
   describe ".init" do
     it "requires token or client id and client secret" do
@@ -18,7 +22,7 @@ RSpec.describe "teamsnap_rb" do
     it "initializes with default url and token auth" do
       Typhoeus.stub(%r(#{default_url})).and_return(response)
 
-      TeamSnap.init(:token => "mytoken", :backup_cache => false)
+      TeamSnap.init(:token => "mytoken")
     end
 
     it "requires client secret when given client id" do
@@ -31,7 +35,7 @@ RSpec.describe "teamsnap_rb" do
       Typhoeus.stub(/#{default_url}/).and_return(response)
 
       TeamSnap.init(
-        :client_id => "myclient", :client_secret => "mysecret", :backup_cache => false
+        :client_id => "myclient", :client_secret => "mysecret"
       )
     end
 
@@ -39,190 +43,198 @@ RSpec.describe "teamsnap_rb" do
       Typhoeus.stub(/#{specified_url}/).and_return(response)
 
       TeamSnap.init(
-        :client_id => "myclient", :client_secret => "mysecret", :backup_cache => false,
+        :client_id => "myclient", :client_secret => "mysecret",
         :url => specified_url
       )
     end
   end
-end
-
-RSpec.describe "teamsnap_rb", :vcr => true do
-  before(:all) do
-    VCR.use_cassette("apiv3-init") do
-      TeamSnap.init(
-        :url => ROOT_TEST_URL,
-        :backup_cache => false,
-        :client_id => "classic",
-        :client_secret => "dont_tell_the_cops"
-      )
-    end
-  end
-
-  it "registers new classes via introspection of the root collection" do
-    expect { TeamSnap::Team }.to_not raise_error
-  end
-
-  it "handles fetching data via queries" do
-    ts = TeamSnap::Team.search(:id => 1)
-
-    expect(ts).to_not be_empty
-    expect(ts[0].id).to eq(1)
-  end
-
-  it "handles queries with no data" do
-    ts = TeamSnap::Team.search(:id => 0)
-
-    expect(ts).to be_empty
-  end
 
-  it "raises an exception when a query is invalid" do
-    expect {
-      TeamSnap::Team.search(:foo => :bar)
-    }.to raise_error(
-      ArgumentError,
-      "Invalid argument(s). Valid argument(s) are [:id, :team_id, :user_id, :division_id]"
-    )
-  end
-
-  it "handles executing an action via commands" do
-    ms = TeamSnap::Member.disable_member(:member_id => 1)
+  describe ".run" do
+    context "works when" do
+      after(:each) do
+        VCR.use_cassette("apiv3-init") do
+          TeamSnap.init(
+            :url => ROOT_TEST_URL,
+            :client_id => client_id,
+            :client_secret => client_secret
+          )
+        end
+      end
 
-    expect(ms).to_not be_empty
-    expect(ms[0].id).to eq(1)
-  end
+      it "calls client_send with the given attributes" do
+        expect(TeamSnap).to receive("client_send").with(any_args).and_call_original
+      end
 
-  it "handles executing an action via commands with multiple params" do
-    TeamSnap.init(
-      :url => ROOT_TEST_URL,
-      :backup_cache => false,
-      :token => "6-classic-dont_tell_the_cops"
-    )
-
-    ms = TeamSnap::Team.invite(
-      :team_id => 1, :member_id => [9, 11], :notify_as_member_id => 3,
-      :introduction => "Welcome! This is our team\n ...the superstars!"
-    )
-
-    expect(ms.size).to eq(2)
-    expect(ms.map(&:id)).to eq([9, 11])
-    expect(ms.map(&:is_invited)).to eq([true, true])
-  end
+      it "the API responds and loads the collection" do
+        expect(TeamSnap::Response).to receive("load_collection").with(any_args).and_call_original
+      end
+    end
 
-  it "raises and exception when a command is invalid" do
-    expect {
-      TeamSnap::Member.disable_member(:foo => :bar)
-    }.to raise_error(
-      ArgumentError,
-      "Invalid argument(s). Valid argument(s) are [:member_id]"
-    )
-  end
+    it "processes the response" do
+      VCR.use_cassette("apiv3-init") do
+        TeamSnap.init(
+          :url => ROOT_TEST_URL,
+          :client_id => client_id,
+          :client_secret => client_secret
+        )
+      end
 
-  it "can handle errors generated by command" do
-    expect {
-      TeamSnap::Member.disable_member
-    }.to raise_error(
-      TeamSnap::Error,
-      "You must provide the member_id."
-    )
+      client = TeamSnap::Client.new({
+        :url => ROOT_TEST_URL,
+        :client_id => client_id,
+        :client_secret => client_secret
+      })
+      via = :get
+      href = "/"
+      args = {}
+
+      expect(TeamSnap.run(client, via, href, args).fetch(:links)).to_not be_empty
+      expect(TeamSnap.run(client, via, href, args).fetch(:queries)).to_not be_empty
+      expect(TeamSnap.run(client, via, href, args).fetch(:commands)).to_not be_empty
+      expect(TeamSnap.run(client, via, href, args).fetch(:href)).to eq(ROOT_TEST_URL + href)
+    end
   end
 
-  it "adds .find if .search is available" do
-    t = TeamSnap::Team.find(1)
+  describe ".client_send" do
+    let(:client) {
+      TeamSnap::Client.new({
+        :url => ROOT_TEST_URL,
+        :client_id => client_id,
+        :client_secret => client_secret
+      })
+    }
+
+    context "when sent a known `via`" do
+      it "calls GET on the given client" do
+        via = :get
+        href = "/"
+        args = {}
+
+        expect(client).to receive(via).with(href, args).and_call_original
+        TeamSnap.client_send(client, via, href, args)
+      end
 
-    expect(t.id).to eq(1)
-  end
+      it "calls DELETE on the given client" do
+        via = :delete
+        href = "/"
+        args = {}
 
-  it "raises an exception if .find returns nothing" do
-    expect {
-      TeamSnap::Team.find(0)
-    }.to raise_error(
-      TeamSnap::NotFound,
-      "Could not find a TeamSnap::Team with an id of '0'."
-    )
-  end
+        expect(client).to receive(via).with(href, args).and_call_original
+        TeamSnap.client_send(client, via, href, args)
+      end
 
-  it "can follow singular links" do
-    m = TeamSnap::Member.find(3)
-    t = m.team
+      it "calls POST on the given client" do
+        via = :post
+        href = "/"
+        args = {}
 
-    expect(t.id).to eq(1)
-  end
+        expect(client).to receive(via).with(href).and_call_original
+        TeamSnap.client_send(client, via, href, args)
+      end
 
-  it "can handle links with no data" do
-    m = TeamSnap::Member.find(1)
-    as = m.assignments
+      it "calls PATCH on the given client" do
+        via = :patch
+        href = "/"
+        args = {}
 
-    expect(as).to be_empty
-  end
+        expect(client).to receive(via).with(href).and_call_original
+        TeamSnap.client_send(client, via, href, args)
+      end
+    end
 
-  it "can follow plural links" do
-    t = TeamSnap::Team.find(1)
-    ms = t.members
+    context "when sent unknown `via`" do
+      it "responds with an error" do
+        expect {
+          TeamSnap.client_send(client, :unknown, "/", {})
+        }.to raise_error(
+          TeamSnap::Error,
+          "Don't know how to run `unknown`"
+        )
+      end
 
-    expect(ms.size).to eq(16)
-  end
+      it "responds with an error" do
+        expect {
+          TeamSnap.client_send(client, :head, "/", {})
+        }.to raise_error(
+          TeamSnap::Error,
+          "Don't know how to run `head`"
+        )
+      end
 
-  it "can use bulk load" do
-    cs = TeamSnap.bulk_load(:team_id => 1, :types => "team,member")
+      it "responds with an error" do
+        expect {
+          TeamSnap.client_send(client, :options, "/", {})
+        }.to raise_error(
+          TeamSnap::Error,
+          "Don't know how to run `options`"
+        )
+      end
 
-    expect(cs).to_not be_empty
-    expect(cs.size).to eq(17)
-    expect(cs[0]).to be_a(TeamSnap::Team)
-    expect(cs[0].id).to eq(1)
-    cs[3..17].each.with_index(5) do |c, idx|
-      expect(c).to be_a(TeamSnap::Member)
-      expect(c.id).to eq(idx)
+      it "responds with an error" do
+        expect {
+          TeamSnap.client_send(client, :trace, "/", {})
+        }.to raise_error(
+          TeamSnap::Error,
+          "Don't know how to run `trace`"
+        )
+      end
     end
   end
 
-  it "can handle an empty bulk load" do
-    cs = TeamSnap.bulk_load(:team_id => 0, :types => "team,member")
-
-    expect(cs).to be_empty
-  end
-
-  it "can handle an error with bulk load" do
-    expect {
-      TeamSnap.bulk_load
-    }.to raise_error(
-      TeamSnap::Error,
-      "You must include a team_id parameter"
-    )
-  end
-
-  it "adds href to items" do
-    m = TeamSnap::Member.find(1)
-
-    expect(m.href).to eq("#{ROOT_TEST_URL}/members/1")
-  end
+  describe ".bulk_load" do
+    before(:all) do
+      VCR.use_cassette("apiv3-init") do
+        TeamSnap.init(
+          :url => ROOT_TEST_URL,
+          :client_id => "classic",
+          :client_secret => "dont_tell_the_cops"
+        )
+      end
+    end
 
-  context "supports relations with expected behaviors" do
-    let(:event) { TeamSnap::Event.find(1) }
+    it "can use bulk load" do
+      cs = TeamSnap.bulk_load(
+        TeamSnap.root_client,
+        :team_id => 1,
+        :types => "team,member"
+      )
 
-    context "when a plural relation is called" do
-      it "responds with an array of objects when successful" do
-        a = event.availabilities
-        expect(a.size).to be > 0
-        expect(a).to be_an(Array)
+      expect(cs).to_not be_empty
+      expect(cs.size).to eq(18)
+      expect(cs[0]).to be_a(TeamSnap::Team)
+      expect(cs[0].id).to eq(1)
+      cs[3..17].each.with_index(4) do |c, idx|
+        expect(c).to be_a(TeamSnap::Member)
+        expect(c.id).to eq(idx)
       end
+    end
 
-      it "responds with an empty array when no objects exist" do
-        a = event.assignments
-        expect(a.size).to eq(0)
-        expect(a).to be_an(Array)
-      end
+    it "can handle an empty bulk load" do
+      cs = TeamSnap.bulk_load(
+        TeamSnap.root_client,
+        :team_id => 0,
+        :types => "team,member"
+      )
+
+      expect(cs).to be_empty
     end
 
-    context "when a singular relation is called" do
-      it "responds with the object if it exists" do
-        a = event.team
-        expect(a).to be_a(TeamSnap::Team)
-      end
+    it "expects a client as the first parameter" do
+      expect {
+        TeamSnap.bulk_load
+      }.to raise_error(
+        ArgumentError,
+        "wrong number of arguments (0 for 1+)"
+      )
+    end
 
-      it "responds with nil if it does NOT exist" do
-        a = event.division_location
-        expect(a).to be_a(NilClass)
-      end
+    it "can handle an error with bulk load" do
+      expect {
+        TeamSnap.bulk_load(TeamSnap.root_client)
+      }.to raise_error(
+        TeamSnap::Error,
+        "You must include a team_id parameter"
+      )
     end
   end
 end