opentok 0.1.3 → 2.2.0

data/spec/opentok/archives_spec.rb

@@ -0,0 +1,91 @@
+require "opentok/archives"
+require "opentok/opentok"
+require "opentok/version"
+require "opentok/archive"
+require "opentok/archive_list"
+
+require "spec_helper"
+
+describe OpenTok::Archives do
+
+  let(:api_key) { "123456" }
+  let(:api_secret) { "1234567890abcdef1234567890abcdef1234567890" }
+  let(:session_id) { "SESSIONID" }
+  let(:archive_name) { "ARCHIVE NAME" }
+  let(:started_archive_id) { "30b3ebf1-ba36-4f5b-8def-6f70d9986fe9" }
+  let(:findable_archive_id) { "f6e7ee58-d6cf-4a59-896b-6d56b158ec71" }
+  let(:deletable_archive_id) { "832641bf-5dbf-41a1-ad94-fea213e59a92" }
+
+  let(:opentok) { OpenTok::OpenTok.new api_key, api_secret }
+  let(:archives) { opentok.archives }
+  subject { archives }
+
+  it { should be_an_instance_of OpenTok::Archives }
+
+  it "should create archives", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+    archive = archives.create session_id
+    expect(archive).to be_an_instance_of OpenTok::Archive
+    expect(archive.session_id).to eq session_id
+    expect(archive.id).not_to be_nil
+  end
+
+  it "should create named archives", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+    archive = archives.create session_id, :name => archive_name
+    expect(archive).to be_an_instance_of OpenTok::Archive
+    expect(archive.session_id).to eq session_id
+    expect(archive.name).to eq archive_name
+  end
+
+
+  it "should stop archives", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+    archive = archives.stop_by_id started_archive_id
+    expect(archive).to be_an_instance_of OpenTok::Archive
+    expect(archive.status).to eq "stopped"
+  end
+
+  it "should find archives by id", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+    archive = archives.find findable_archive_id
+    expect(archive).to be_an_instance_of OpenTok::Archive
+    expect(archive.id).to eq findable_archive_id
+  end
+
+  it "should delete an archive by id", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+    success = archives.delete_by_id deletable_archive_id
+    expect(success).to be_true
+    # expect(archive.status).to eq ""
+  end
+
+  # TODO: context "with a session that has no participants" do
+  #   let(:session_id) { "" }
+  #   it "should refuse to create archives with appropriate error" do
+  #     expect { archives.create session_id }.to raise_error
+  #   end
+  # end
+
+  context "when many archives are created" do
+    it "should return all archives", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+      archive_list = archives.all
+      expect(archive_list).to be_an_instance_of OpenTok::ArchiveList
+      expect(archive_list.total).to eq 6
+    end
+
+    it "should return archives with an offset", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+      archive_list = archives.all :offset => 3
+      expect(archive_list).to be_an_instance_of OpenTok::ArchiveList
+      expect(archive_list.count).to eq 3
+    end
+
+    it "should return count number of archives", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+      archive_list = archives.all :count => 2
+      expect(archive_list).to be_an_instance_of OpenTok::ArchiveList
+      expect(archive_list.count).to eq 2
+    end
+
+    it "should return part of the archives when using offset and count", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+      archive_list = archives.all :count => 4, :offset => 2
+      expect(archive_list).to be_an_instance_of OpenTok::ArchiveList
+      expect(archive_list.count).to eq 4
+    end
+  end
+
+end

data/spec/opentok/opentok_spec.rb

@@ -0,0 +1,144 @@
+require "opentok/opentok"
+require "opentok/version"
+
+require "spec_helper"
+require "shared/opentok_generates_tokens"
+
+describe OpenTok::OpenTok do
+
+  let(:opentok) { OpenTok::OpenTok.new api_key, api_secret }
+  subject { opentok }
+
+  context "when initialized properly" do
+
+    let(:api_key) { "123456" }
+    let(:api_secret) { "1234567890abcdef1234567890abcdef1234567890" }
+
+    let(:default_api_url) { "https://api.opentok.com" }
+
+    it { should be_an_instance_of OpenTok::OpenTok  }
+
+    it "should have an api_key property" do
+      expect(opentok.api_key).to eq api_key
+    end
+
+    it "has the default api_url set" do
+      expect(opentok.api_url).to eq default_api_url
+    end
+
+    include_examples "opentok generates tokens"
+
+    describe "#create_session" do
+
+      let(:location) { '12.34.56.78' }
+
+      it "creates default sessions", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session
+        expect(session).to be_an_instance_of OpenTok::Session
+        # TODO: do we need to be any more specific about what a valid session_id looks like?
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :routed
+        expect(session.location).to eq nil
+      end
+
+      it "creates relayed media sessions", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :media_mode => :relayed
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :relayed
+        expect(session.location).to eq nil
+      end
+
+      it "creates routed media sessions", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :media_mode => :routed
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :routed
+        expect(session.location).to eq nil
+      end
+
+      it "creates sessions with a location hint", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :location => location
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :routed
+        expect(session.location).to eq location
+      end
+
+      it "creates relayed media sessions with a location hint", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :media_mode => :relayed, :location => location
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :relayed
+        expect(session.location).to eq location
+      end
+
+      it "creates routed media sessions with a location hint", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :media_mode => :routed, :location => location
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :routed
+        expect(session.location).to eq location
+      end
+
+      it "creates routed media sessions for invalid media modes", :vcr => { :erb => { :version => OpenTok::VERSION } } do
+        session = opentok.create_session :media_mode => :blah
+        expect(session).to be_an_instance_of OpenTok::Session
+        expect(session.session_id).to be_an_instance_of String
+        expect(session.media_mode).to eq :routed
+        expect(session.location).to eq nil
+      end
+
+    end
+
+    context "with an api_key that's a number" do
+      let(:api_key) { 123456 }
+
+      it { should be_an_instance_of(OpenTok::OpenTok) }
+
+      it "changes api_key property to string" do
+        expect(opentok.api_key).to eq api_key.to_s
+      end
+
+      it "should have an api_url property" do
+        expect(opentok.api_url).to eq default_api_url
+      end
+
+      # TODO: maybe i don't need to run all the tests
+      include_examples "opentok generates tokens"
+    end
+
+    context "with an additional api_url" do
+      let(:api_url) { "http://example.opentok.com" }
+      let(:opentok) { OpenTok::OpenTok.new api_key, api_secret, api_url }
+
+      it { should be_an_instance_of(OpenTok::OpenTok) }
+
+      it "should have an api_url property" do
+        expect(opentok.api_url).to eq api_url
+      end
+
+      # TODO: i don't need to run all the tests, just a set that checks for the URL's effect
+      # include_examples "generates tokens"
+    end
+
+  end
+
+  # ah, the magic of duck typing. the errors raised don't have any specific description
+  # see discussion here: https://www.ruby-forum.com/topic/194593
+  context "when initialized improperly" do
+    context "with no arguments" do
+      subject { -> { @opentok = OpenTOk::OpenTok.new } }
+      it { should raise_error }
+    end
+    context "with just an api_key" do
+      subject { -> { @opentok = OpenTOk::OpenTok.new "123456" } }
+      it { should raise_error }
+    end
+    context "with arguments of the wrong type" do
+      subject { -> { @opentok = OpenTOk::OpenTok.new api_key: "123456" } }
+      it { should raise_error }
+    end
+  end
+
+end

data/spec/opentok/session_spec.rb

@@ -0,0 +1,71 @@
+require "opentok/session"
+
+require "spec_helper"
+require "shared/session_generates_tokens"
+
+describe OpenTok::Session do
+
+  let(:api_key) { "123456" }
+  let(:api_secret) { "1234567890abcdef1234567890abcdef1234567890" }
+  let(:session_id) { "SESSIONID" }
+
+  let(:session) { OpenTok::Session.new api_key, api_secret, session_id }
+  subject { session }
+
+  context "when initialized with no options" do
+    it { should be_an_instance_of OpenTok::Session }
+    it "should have an api_key property" do
+      expect(session.api_key).to eq api_key
+    end
+    it "should have an api_secret property" do
+      expect(session.api_secret).to eq api_secret
+    end
+    it "should have a session_id property" do
+      expect(session.session_id).to eq session_id
+    end
+    it "should be represented by session_id when coerced to a string" do
+      expect(session.to_s).to eq session_id
+    end
+    it "should have the default media mode of routed" do
+      expect(session.media_mode).to eq :routed
+    end
+    it "should not have a location value" do
+      expect(session.location).to eq nil
+    end
+    include_examples "session generates tokens"
+  end
+
+  context "when initialized with options" do
+    let(:default_opts) { {} }
+    let(:session) { OpenTok::Session.new api_key, api_secret, session_id, default_opts }
+
+    it { should be_an_instance_of OpenTok::Session }
+    it "should have an api_key property" do
+      expect(session.api_key).to eq api_key
+    end
+    it "should have an api_secret property" do
+      expect(session.api_secret).to eq api_secret
+    end
+    it "should have a session_id property" do
+      expect(session.session_id).to eq session_id
+    end
+    it "should be represented by session_id when coerced to a string" do
+      expect(session.to_s).to eq session_id
+    end
+    it "should have media mode when set in options" do
+      opts = { :media_mode => :routed }
+      session = OpenTok::Session.new api_key, api_secret, session_id, opts
+      expect(session.media_mode).to eq :routed
+      opts = { :media_mode => :relayed }
+      session = OpenTok::Session.new api_key, api_secret, session_id, opts
+      expect(session.media_mode).to eq :relayed
+    end
+    it "should have a location value when set in options" do
+      opts = { :location => '12.34.56.78' }
+      session = OpenTok::Session.new api_key, api_secret, session_id, opts
+      expect(session.location).to eq opts[:location]
+    end
+    include_examples "session generates tokens"
+  end
+
+end

data/spec/shared/opentok_generates_tokens.rb

@@ -0,0 +1,62 @@
+require "opentok/constants"
+require "matchers/token"
+
+shared_examples "opentok generates tokens" do
+  describe "#generate_token" do
+    # these must be known quantities because generate_token will have to verify that the session_id
+    # belongs to the api_key, it doesn't have the luxury of getting that type of failure in an error
+    # response from the server
+    let(:api_key) { "123456" }
+    let(:api_secret) { "1234567890abcdef1234567890abcdef1234567890" }
+    let(:session_id) { "1_MX4xMjM0NTZ-flNhdCBNYXIgMTUgMTQ6NDI6MjMgUERUIDIwMTR-MC40OTAxMzAyNX4" }
+    let(:default_role) { :publisher }
+
+    it "generates plain tokens" do
+      plain_token = opentok.generate_token session_id
+      expect(plain_token).to be_an_instance_of String
+      expect(plain_token).to carry_token_data :session_id => session_id
+      expect(plain_token).to carry_token_data :api_key => api_key
+      expect(plain_token).to carry_token_data :role => default_role
+      expect(plain_token).to carry_token_data [:nonce, :create_time]
+      expect(plain_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with an expire time" do
+      expire_time = Time.now + (60*60*24)
+      expiring_token = opentok.generate_token session_id, :expire_time => expire_time
+      expect(expiring_token).to be_an_instance_of String
+      expect(expiring_token).to carry_token_data :session_id => session_id
+      expect(expiring_token).to carry_token_data :api_key => api_key
+      expect(expiring_token).to carry_token_data :role => default_role
+      expect(expiring_token).to carry_token_data :expire_time => expire_time.to_i
+      expect(expiring_token).to carry_token_data [:nonce, :create_time]
+      expect(expiring_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with a role" do
+      role = :moderator
+      role_token = opentok.generate_token session_id, :role => role
+      expect(role_token).to be_an_instance_of String
+      expect(role_token).to carry_token_data :session_id => session_id
+      expect(role_token).to carry_token_data :api_key => api_key
+      expect(role_token).to carry_token_data :role => role
+      expect(role_token).to carry_token_data [:nonce, :create_time]
+      expect(role_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with data" do
+      data = "name=Johnny"
+      data_bearing_token = opentok.generate_token session_id, :data => data
+      expect(data_bearing_token).to be_an_instance_of String
+      expect(data_bearing_token).to carry_token_data :session_id => session_id
+      expect(data_bearing_token).to carry_token_data :api_key => api_key
+      expect(data_bearing_token).to carry_token_data :role => default_role
+      expect(data_bearing_token).to carry_token_data :data => data
+      expect(data_bearing_token).to carry_token_data [:nonce, :create_time]
+      expect(data_bearing_token).to carry_valid_token_signature api_secret
+    end
+
+    # TODO a context about using a bad session_id
+  end
+
+end

data/spec/shared/session_generates_tokens.rb

@@ -0,0 +1,63 @@
+require "opentok/constants"
+require "matchers/token"
+
+shared_examples "session generates tokens" do
+  describe "#generate_token" do
+    # these must be known quantities because generate_token will have to verify that the session_id
+    # belongs to the api_key, it doesn't have the luxury of getting that type of failure in an error
+    # response from the server
+    let(:api_key) { "123456" }
+    let(:api_secret) { "1234567890abcdef1234567890abcdef1234567890" }
+    let(:session_id) { "1_MX4xMjM0NTZ-flNhdCBNYXIgMTUgMTQ6NDI6MjMgUERUIDIwMTR-MC40OTAxMzAyNX4" }
+    let(:default_role) { :publisher }
+
+    it "generates plain tokens" do
+      plain_token = session.generate_token
+      expect(plain_token).to be_an_instance_of String
+      expect(plain_token).to carry_token_data :session_id => session_id
+      expect(plain_token).to carry_token_data :api_key => api_key
+      expect(plain_token).to carry_token_data :role => default_role
+      expect(plain_token).to carry_token_data [:nonce, :create_time]
+      expect(plain_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with an expire time" do
+      expire_time = Time.now + (60*60*24)
+      expiring_token = session.generate_token :expire_time => expire_time
+      expect(expiring_token).to be_an_instance_of String
+      expect(expiring_token).to carry_token_data :session_id => session_id
+      expect(expiring_token).to carry_token_data :api_key => api_key
+      expect(expiring_token).to carry_token_data :role => default_role
+      expect(expiring_token).to carry_token_data :expire_time => expire_time.to_i
+      expect(expiring_token).to carry_token_data [:nonce, :create_time]
+      expect(expiring_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with a role" do
+      role = :moderator
+      role_token = session.generate_token :role => role
+      expect(role_token).to be_an_instance_of String
+      expect(role_token).to carry_token_data :session_id => session_id
+      expect(role_token).to carry_token_data :api_key => api_key
+      expect(role_token).to carry_token_data :role => role
+      expect(role_token).to carry_token_data [:nonce, :create_time]
+      expect(role_token).to carry_valid_token_signature api_secret
+    end
+
+    it "generates tokens with data" do
+      data = "name=Johnny"
+      data_bearing_token = session.generate_token :data => data
+      expect(data_bearing_token).to be_an_instance_of String
+      expect(data_bearing_token).to carry_token_data :session_id => session_id
+      expect(data_bearing_token).to carry_token_data :api_key => api_key
+      expect(data_bearing_token).to carry_token_data :role => default_role
+      expect(data_bearing_token).to carry_token_data :data => data
+      expect(data_bearing_token).to carry_token_data [:nonce, :create_time]
+      expect(data_bearing_token).to carry_valid_token_signature api_secret
+    end
+
+
+    # TODO a context about using a bad session_id
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,15 +1,14 @@
-require 'opentok'
-
-require 'vcr'
-require 'webmock'
+require "vcr"
 
 VCR.configure do |c|
   c.cassette_library_dir     = 'spec/cassettes'
   c.hook_into                :webmock
-  c.default_cassette_options = { :record => :new_episodes }
-  c.allow_http_connections_when_no_cassette=true
+  c.default_cassette_options = { :match_requests_on => [:method, :uri, :query, :body, :headers] }
+  c.configure_rspec_metadata!
 end
 
 RSpec.configure do |c|
-  c.extend VCR::RSpec::Macros
+  # so we can use :vcr rather than :vcr => true;
+  # in RSpec 3 this will no longer be necessary.
+  c.treat_symbols_as_metadata_keys_with_true_values = true
 end