telestream_cloud 1.1.0 → 2.0.0.1

data/spec/heroku_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe TelestreamCloud::Video do
-  before(:each) do
-    cloud_json = "{\"s3_videos_bucket\":\"my_bucket\",\"id\":\"my_cloud_id\"}"
-    stub_http_request(:get, /api.example.com:443\/v2\/factories\/my_cloud_id.json/).
-      to_return(:body => cloud_json)
-
-    my_heroku_url = "http://access_key:secret_key@api.example.com:443/my_cloud_id"
-    ENV['PANDASTREAM_URL']= my_heroku_url
-  end
-
-  it "should get all videos" do
-    TelestreamCloud.configure_heroku
-
-    videos_json = "[]"
-    stub_http_request(:get, /api.example.com:443\/v3.0\/videos.json/).to_return(:body => videos_json)
-
-    TelestreamCloud::Video.all.should be_empty
-  end
-
-  it "should get all videos" do
-    TelestreamCloud.configure ENV['PANDASTREAM_URL']
-
-    videos_json = "[]"
-    stub_http_request(:get, /api.example.com:443\/v3.0\/videos.json/).to_return(:body => videos_json)
-
-    TelestreamCloud::Video.all.should be_empty
-  end
-
-
-end

data/spec/panda_spec.rb

@@ -1,206 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'timecop'
-
-describe TelestreamCloud do
-  before(:each) do
-    new_time = Time.utc(2010, 1, 12, 1, 0, 0)
-    Timecop.freeze(new_time)
-  end
-
-  describe "when not connected" do
-
-    ["get", "post", "put", "delete"].each do |method|
-      it "should raise error for #{method}" do
-        lambda {
-          TelestreamCloud.send(method, nil, nil)
-        }.should raise_error(TelestreamCloud::ConfigurationError, "Telestream Cloud is not configured!")
-      end
-    end
-
-  end
-
-  describe "root configuration with hash" do
-    it "should not fail is access_key and secret_key are given" do
-      proc do
-        TelestreamCloud.configure({:access_key => "bar", :secret_key => "baz"})
-      end.should_not raise_error(TelestreamCloud::ConfigurationError)
-    end
-
-    it "should fail if access_key or secret_key are missing" do
-      proc do
-        TelestreamCloud.configure({:secret_key => "baz"})
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-      proc do
-        TelestreamCloud.configure({:access_key => "bar"})
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-      proc do
-        TelestreamCloud.configure({})
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-    end
-  end
-
-  describe "root configuration with block" do
-    it "should not fail is access_key and secret_key are given" do
-      proc do
-        TelestreamCloud.configure do
-          access_key "bar"
-          secret_key "baz"
-        end
-      end.should_not raise_error(TelestreamCloud::ConfigurationError)
-    end
-
-    it "should fail if access_key or secret_key are missing" do
-      proc do
-        TelestreamCloud.configure do
-          secret_key "baz"
-        end
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-      proc do
-        TelestreamCloud.configure do
-          access_key "bar"
-        end
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-      proc do
-        TelestreamCloud.configure do
-        end
-      end.should raise_error(TelestreamCloud::ConfigurationError)
-    end
-  end
-
-  shared_examples_for "Connected" do
-
-    it "should make get request with signed request to panda server" do
-      stub_http_request(:get, "http://myapihost:85/v3.0/videos?access_key=my_access_key&factory_id=my_cloud_id&signature=ArhKqAFUwLQl9RhSmnOv5L2CMWhr0ZFOxA0B9IKIg8I=&timestamp=2010-01-12T01%3A00%3A00.000000Z").to_return(:body => "{\"abc\":\"d\"}")
-      @tc.get("/videos").should == {'abc' => 'd'}
-    end
-
-    it "should create a signed version of the parameters" do
-      signed_params = @tc.signed_params('POST',
-                                           '/videos.json',
-                                           {"param1" => 'one', "param2" => 'two'}
-                                           )
-      signed_params.should == {
-        'access_key' => "my_access_key",
-        'timestamp' => "2010-01-12T01:00:00.000000Z",
-        'factory_id' => 'my_cloud_id',
-        'signature' => 'A/7DSazLSnr8wiX2QUKCWE3C1IXAAdIpEcnFF4Qc8Rw=',
-        'param1' => 'one',
-        'param2' => 'two'
-      }
-    end
-
-    it "should create a signed version of the parameters without additional arguments" do
-      @tc.signed_params('POST', '/videos.json').should == {
-        'access_key' => "my_access_key",
-        'timestamp' => "2010-01-12T01:00:00.000000Z",
-        'factory_id' => 'my_cloud_id',
-        'signature' => 'Ne/W+cvZAZ4yE70PcXgLbPieGrwdaCX9WPUCQeJBPhs='
-      }
-    end
-
-
-    it "should create a signed version of the parameters and difficult characters" do
-      signed_params = @tc.signed_params('POST',
-                                           '/videos.json',
-                                           {"tilde" => '~', "space" => ' '}
-                                           )
-      signed_params.should == {
-        'access_key' => "my_access_key",
-        'timestamp' => "2010-01-12T01:00:00.000000Z",
-        'factory_id' => 'my_cloud_id',
-        'signature' => 'g3shJBMg/7Kmbj3kl0eb4ziT3zounhFpC5jJIg+3Kts=',
-        'tilde' => '~',
-        'space' => ' '
-      }
-    end
-
-
-    it "should not include file inside the signature" do
-      @tc.signed_params('POST', '/videos.json', { "file" => "my_file" }).should == {
-        'access_key' => "my_access_key",
-        'timestamp' => "2010-01-12T01:00:00.000000Z",
-        'factory_id' => 'my_cloud_id',
-        'signature' => 'Ne/W+cvZAZ4yE70PcXgLbPieGrwdaCX9WPUCQeJBPhs=',
-        'file' => "my_file"
-      }
-    end
-
-    it "should stringify keys" do
-      @tc.signed_params('POST', '/videos.json', { :file => "symbol_key" }).should == {
-        'access_key' => "my_access_key",
-        'timestamp' => "2010-01-12T01:00:00.000000Z",
-        'factory_id' => 'my_cloud_id',
-        'signature' => 'Ne/W+cvZAZ4yE70PcXgLbPieGrwdaCX9WPUCQeJBPhs=',
-        'file' => "symbol_key"
-      }
-    end
-  end
-
-  describe "TelestreamCloud.connect " do
-    before(:each) do
-      @tc = TelestreamCloud.connect!({"access_key" => "my_access_key", "secret_key" => "my_secret_key", "api_host" => "myapihost", "api_port" => 85, "factory_id" => 'my_cloud_id'})
-    end
-   it_should_behave_like "Connected"
-  end
-
-  describe "TelestreamCloud.connect with symbols" do
-    before(:each) do
-      @tc = TelestreamCloud.connect!({:access_key => "my_access_key", :secret_key => "my_secret_key", :api_host => "myapihost", :api_port => 85, :factory_id => 'my_cloud_id'})
-    end
-
-   it_should_behave_like "Connected"
-  end
-
-  describe "Panda::Connection.new" do
-     before(:each) do
-       @tc = TelestreamCloud::Connection.new({"access_key" => "my_access_key", "secret_key" => "my_secret_key", "api_host" => "myapihost", "api_port" => 85, "factory_id" => 'my_cloud_id'})
-     end
-    it_should_behave_like "Connected"
-  end
-
-  describe "Using hash as a return format" do
-
-    before(:each) do
-      @tc = TelestreamCloud::Connection.new({"access_key" => "my_access_key", "secret_key" => "my_secret_key", "api_host" => "myapihost", "api_port" => 85, "factory_id" => 'my_cloud_id' })
-    end
-
-    it "should make get request" do
-      stub_http_request(:get, "http://myapihost:85/v3.0/videos?access_key=my_access_key&factory_id=my_cloud_id&signature=ArhKqAFUwLQl9RhSmnOv5L2CMWhr0ZFOxA0B9IKIg8I=&timestamp=2010-01-12T01%3A00%3A00.000000Z").to_return(:body => "{\"key\":\"value\"}")
-      @tc.get("/videos").should == {'key' => 'value'}
-    end
-
-  end
-
-  # describe "ActiveSupport::JSON parsing" do
-  #
-  #   it "should use active support if it has been defined and if restclient is used " do
-  #     @tc = Panda::Connection.new({"access_key" => "my_access_key", "secret_key" => "my_secret_key", "api_host" => "myapihost", "api_port" => 85, "cloud_id" => 'my_cloud_id' })
-  #     Panda.adapter = 'restclient'
-  #
-  #     stub_http_request(:get, "http://myapihost:85/v2/videos?access_key=my_access_key&cloud_id=my_cloud_id&signature=DYpg2K6d7kGo%2FuWPO%2FaQgtQmY3BPtFEtQgdQhVe8teM%3D&timestamp=2010-01-12T01%3A00%3A00.000000Z").to_return(:body => "abc")
-  #
-  #
-  #     module ActiveSupport
-  #       class JSON; end
-  #     end
-  #
-  #     ActiveSupport::JSON.should_receive(:decode).with("abc").and_return("blah")
-  #     @tc.get("/videos").should == "blah"
-  #
-  #     Object.send :remove_const, :ActiveSupport
-  #   end
-  # end
-
-  describe "parsing" do
-    it "should raise an error if the response is not JSON parsable" do
-      @connection = TelestreamCloud::Connection.new({"access_key" => "my_access_key", "secret_key" => "my_secret_key", "api_host" => "myapihost", "api_port" => 85, "cloud_id" => 'my_cloud_id' })
-
-      stub_http_request(:get, //).to_return(:body => "blahblah")
-
-      lambda {
-        @connection.get("/fake")
-      }.should raise_error(TelestreamCloud::ServiceNotAvailable)
-    end
-  end
-
-end

data/spec/profile_spec.rb

@@ -1,117 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe TelestreamCloud::Profile do
-  before(:each) do
-    cloud_json = "{\"s3_videos_bucket\":\"my_bucket\",\"id\":\"my_cloud_id\"}"
-    stub_http_request(:get, /api.example.com:85\/v3.0\/factories\/my_cloud_id.json/).
-      to_return(:body => cloud_json)
-
-    TelestreamCloud.configure do
-      access_key "my_access_key"
-      secret_key "my_secret_key"
-      api_host "api.example.com"
-      factory_id 'my_cloud_id'
-      api_port 85
-    end
-
-  end
-
-  it "should create a profile" do
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"123\"}"
-    stub_http_request(:post, /api.example.com:85\/v3.0\/profiles.json/).
-      with(:body => /title=my_profile/).
-        to_return(:body => profile_json)
-
-    profile = TelestreamCloud::Profile.new(:title => "my_profile")
-
-    profile.new?.should == true
-    profile.changed?.should == true
-    profile.save.should == true
-    profile.changed?.should == false
-    profile.id.should == "123"
-    profile.new?.should == false
-
-    profile.changed?.should == false
-
-    profile.title = "new_last_title"
-    profile.changed?.should == true
-  end
-
-
-  it "should update a profile and sending the changed attributes" do
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"123\"}"
-    stub_http_request(:put, /api.example.com:85\/v3.0\/profiles\/999.json/).
-      with{|r| !(r.body =~ /title=my_new_profile_title/) && r.body =~ /width=80/}.
-        to_return(:body => profile_json)
-
-    profile = TelestreamCloud::Profile.new(:id => "999", :title => "my_profile_title")
-
-    profile.width=80
-    profile.new?.should == false
-    profile.save.should == true
-  end
-
-
-  it "should not call update a profile" do
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"123\"}"
-    stub_http_request(:put, /api.example.com:85\/v3.0\/profiles\/123.json/).
-      with(:body => /title=my_profile/).
-        to_return(:body => profile_json)
-
-    profile = TelestreamCloud::Profile.new(:id => "123")
-    profile.title = "my_profile"
-
-    profile.new?.should == false
-    profile.save.should == true
-  end
-
-
-  it "should have a many relation on encodings" do
-    encoding_json = "[{\"abc\":\"efg\",\"id\":456}]"
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"901\"}"
-    stub_http_request(:get, /api.example.com:85\/v3.0\/profiles\/901\/encodings.json/).
-      to_return(:body => encoding_json)
-
-    profile = TelestreamCloud::Profile.new(:title => "my_source_url", :id => "901")
-    profile.encodings.first.id.should ==  456
-  end
-
-  it "should reload the object" do
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"123\"}"
-    stub_http_request(:get, /api.example.com:85\/v3.0\/profiles\/123.json/).
-        to_return(:body => profile_json)
-
-    profile = TelestreamCloud::Profile.new(:id => "123", :title => "my_new_profile_title")
-    profile.title.should == "my_new_profile_title"
-    profile.reload
-    profile.id.should == "123"
-    profile.title.should == "my_profile"
-  end
-
-  it "shoud raise an exeception if it's a new object" do
-    profile = TelestreamCloud::Profile.new(:title => "my_new_profile_title")
-    lambda {
-      profile.reload
-    }.should raise_error("RecordNotFound")
-  end
-
-  it "shoud raise an exeception if it's a new object" do
-    profile_json = "{\"title\":\"my_profile\",\"id\":\"123\"}"
-    stub_http_request(:get, /api.example.com:85\/v3.0\/profiles\/123.json/).
-        to_return(:body => profile_json)
-
-    profile = TelestreamCloud::Profile.find(123)
-    profile.reload.should == profile
-  end
-
-  it "should not delegate scope if the method do not really exist in the scope" do
-    lambda {TelestreamCloud::Profile.reload}.should raise_error(NoMethodError)
-    lambda {TelestreamCloud::Profile.each}.should raise_error(NoMethodError)
-    lambda {TelestreamCloud::Profile.size}.should raise_error(NoMethodError)
-  end
-
-  it "should tell if profile is using a preset" do
-    TelestreamCloud::Profile.new(:title => "abc").preset?.should be_truthy
-    TelestreamCloud::Profile.new(:preset_name => "abc").preset?.should be_falsey
-  end
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'telestream_cloud'
-require 'rspec'
-
-require 'webmock/rspec'
-include WebMock::API
-
-def hputs(*args)
-  puts ERB::Util.html_escape(args.join("\n")).gsub(/\r?\n/, '<br/>') + '<br/>'
-end
-
-RSpec.configure do |config|
-  config.before(:each) do
-    TelestreamCloud.instance_variable_set("@connection", nil)
-    TelestreamCloud.instance_variable_set("@factory", nil)
-  end
-end

data/spec/uploader_spec.rb

@@ -1,143 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-shared_examples_for "uploader" do
-  let(:file_size) { 45_000_000 }
-  let(:file) do
-    double(:file,
-           path: '/foo/bar.mp4',
-           size: file_size
-          )
-  end
-
-  before(:each) do
-    TelestreamCloud.configure do
-      access_key "my_access_key"
-      secret_key "my_secret_key"
-      api_host "api.example.com"
-      factory_id 'my_cloud_id'
-      api_port 85
-    end
-  end
-
-  describe '#upload' do
-    let(:part_size) { 10_000_000 }
-    let(:session_url) { 'http://api.example.com:1234/upload/session?id=1234' }
-
-    let(:video_json) do
-      "{\"id\":\"12345\"}"
-    end
-
-    context 'with valid session' do
-      let(:session_json) do
-        "{\"id\":\"1234\",\"location\":\"#{session_url}\",\"parts\":\"5\",\"part_size\":\"#{part_size}\",\"max_connections\":\"16\"}"
-      end
-
-      before do
-        stub_request(:post, "http://api.example.com:85/v3.0/videos/upload.json")
-          .to_return(body: session_json)
-
-        expect(file).to receive(:read).with(part_size).and_return("chunk").exactly(4).times
-        expect(file).to receive(:read).with(file_size % part_size).and_return("chunk").once
-
-        5.times do |i|
-          expect(file).to receive(:seek).with(i * part_size)
-        end
-      end
-
-      it 'uploads file' do
-        stub_request(:put, session_url).with(headers: { "X-Part" => /[0-3]/ })
-
-        stub_request(:put, session_url)
-        .with(headers: { "X-Part" => 4 }, body: "chunk")
-        .to_return(body: "{\"id\":\"12345\"}")
-
-
-        subject.upload
-        expect(subject).to be_success
-        expect(subject.video).not_to be_nil
-        expect(subject.video.id).to eq("12345")
-      end
-
-      it 'retries missing chunks' do
-        stub_request(:put, session_url)
-        stub_request(:put, session_url).with(headers: { "X-Part" => 3 })
-          .to_return({body: ""}).then.to_return({body: video_json})
-
-        stub_request(:get, session_url).to_return(body: JSON.generate(missing_parts: [3]))
-
-        expect(file).to receive(:read).with(part_size).and_return("chunk")
-        expect(file).to receive(:seek).with(3 * part_size)
-
-        subject.upload
-
-        expect(subject).to be_success
-        expect(subject.video).not_to be_nil
-        expect(subject.video.id).to eq("12345")
-      end
-
-      it 'fails after few tries' do
-        stub_request(:put, session_url)
-        stub_request(:get, session_url).to_return(body: JSON.generate(missing_parts: [3]))
-
-        expect(file).to receive(:read).with(part_size).and_return("chunk").exactly(4).times
-        expect(file).to receive(:seek).with(3 * part_size).exactly(4).times
-
-        subject.upload
-
-        expect(subject.status).to eq(:failed)
-        expect(subject.video).to be_nil
-        expect(subject.error).to be_a(TelestreamCloud::Uploader::MissingPartError)
-      end
-    end
-
-    context 'with invalid session' do
-      let(:session_json) do
-        "{\"error\":\"NotAuthorized\",\"message\":\"Message\"}"
-      end
-
-      it 'fails' do
-        stub_request(:post, "http://api.example.com:85/v3.0/videos/upload.json")
-          .to_return(body: session_json)
-
-        subject.upload
-
-        expect(subject.status).to eq(:failed)
-        expect(subject.error).to be_a(TelestreamCloud::Uploader::UploadError)
-      end
-    end
-  end
-
-  describe '.upload' do
-    it 'calls #upload' do
-      video = double(:video)
-      expect_any_instance_of(subject.class).to receive(:upload)
-      expect_any_instance_of(subject.class).to receive(:video).and_return(video)
-
-      expect(subject.class.upload(file: file)).to eq(video)
-    end
-
-    it 'calls #upload with retries options' do
-      video = double(:video)
-      expect_any_instance_of(subject.class).to receive(:upload).with(5)
-      expect_any_instance_of(subject.class).to receive(:video).and_return(video)
-
-      expect(subject.class.upload(file: file, retries: 5)).to eq(video)
-    end
-  end
-end
-
-describe TelestreamCloud::Uploader do
-  subject do
-    TelestreamCloud::Uploader.new(file: file)
-  end
-
-  it_behaves_like "uploader"
-end
-
-describe TelestreamCloud::ParallelUploader do
-  subject do
-    TelestreamCloud::ParallelUploader.new(file: file)
-  end
-
-  it_behaves_like "uploader"
-end