transmission-rpc-ruby-ext 0.1.0

data/lib/transmission/utils.rb

@@ -0,0 +1,24 @@
+module Transmission
+  module Utils
+    def is_valid_key?(key, attributes)
+      !attributes.select do |attribute|
+        option_keys(key).include? attribute[:field]
+      end.empty?
+    end
+
+    def option_keys(key)
+      split = key.to_s.split '_'
+      dashed = split.join '-'
+      camelcase = split.collect(&:capitalize).join
+      camelcase = camelcase[0].downcase + camelcase[1..-1]
+      [dashed, camelcase]
+    end
+
+    def option_key(key, attributes)
+      selected = attributes.select do |attribute|
+        option_keys(key).include? attribute[:field]
+      end
+      selected.first[:field] unless selected.empty?
+    end
+  end
+end

data/spec/helpers/stubs.rb

@@ -0,0 +1,82 @@
+module Stubs
+  def stub_rpc_request(options = {})
+    host = options[:host] || 'localhost'
+    port = options[:port] || 9091
+    path = options[:path] || '/transmission/rpc'
+    scheme = options[:ssl] ? 'https' : 'http'
+    stub_request(:post, "#{scheme}://#{host}:#{port}#{path}")
+  end
+
+  def stub_get_torrent(body, torrents)
+    stub_rpc_request
+      .with(body: torrent_get_body(body))
+      .to_return(successful_response( arguments: { torrents: torrents } ))
+  end
+
+  def stub_get_session(fields)
+    stub_rpc_request
+      .with(body: session_get_body( fields: fields ))
+      .to_return(successful_response)
+  end
+
+  def stub_set_location_torrent(body)
+    stub_rpc_request
+      .with(body: torrent_set_location_body(body))
+      .to_return(successful_response)
+  end
+
+  def torrent_get_body(arguments = {})
+    args = { fields: Transmission::Fields::TorrentGet.new.to_fields }.merge(arguments)
+    { method: 'torrent-get', arguments: args }.to_json
+  end
+
+  def torrent_add_body(arguments = {})
+    { method: 'torrent-add', arguments: arguments }.to_json
+  end
+
+  def torrent_remove_body(arguments = {})
+    { method: 'torrent-remove', arguments: arguments }.to_json
+  end
+
+  def torrent_set_body(arguments = {})
+    { method: 'torrent-set', arguments: arguments }.to_json
+  end
+
+  def torrent_set_location_body(arguments = {})
+    { method: 'torrent-set-location', arguments: arguments }.to_json
+  end
+
+  def torrent_method_body(method, arguments)
+    { method: method, arguments: arguments }.to_json
+  end
+
+  def session_get_body(arguments = {})
+    { method: 'session-get', arguments: arguments }.to_json
+  end
+
+  def session_set_body(arguments = {})
+    { method: 'session-set', arguments: arguments }.to_json
+  end
+
+  def session_stats_body(arguments = {})
+    { method: 'session-stats', arguments: arguments }.to_json
+  end
+
+  def successful_response(options = {})
+    body = { result: 'success', arguments: (options[:arguments] || {}) }
+    { status: 200, body: body.to_json, headers: options[:headers] || {} }
+  end
+
+  def unsuccessful_response(options = {})
+    body = { result: (options[:result] || ''), arguments: (options[:arguments] || {}) }
+    { status: 200, body: body.to_json, headers: options[:headers] || {} }
+  end
+
+  def unauthorized_response(options = {})
+    { status: 401, body: (options[:body] || {}).to_json, headers: options[:headers] || {} }
+  end
+
+  def conflict_response(options = {})
+    { status: 409, body: (options[:body] || {}).to_json, headers: options[:headers] || {} }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'webmock/rspec'
+require 'coveralls'
+Coveralls.wear!
+
+require_relative File.join('..', 'lib', 'transmission')
+require_relative File.join('helpers', 'stubs')
+
+ENV['TESTING'] = 'true'
+
+RSpec.configure do |config|
+  config.include Stubs
+end

data/spec/transmission/arguments_spec.rb

@@ -0,0 +1,78 @@
+describe Transmission::Arguments do
+  [
+    { className: Transmission::Arguments::SessionSet, arguments: { 'alt-speed-down' => 5 } },
+    { className: Transmission::Arguments::TorrentAdd, arguments: { 'paused' => true } },
+    { className: Transmission::Arguments::TorrentSet, arguments: { 'location' => '/location' } }
+  ].each do |klass|
+
+    describe klass[:className].to_s do
+      describe '#new' do
+        it 'should create an instance with correct arguments' do
+          instance = klass[:className].new
+          expect(instance.arguments.size).to eq(klass[:className]::ATTRIBUTES.size)
+        end
+
+        it 'should create an instance with given arguments' do
+          instance = klass[:className].new klass[:arguments]
+          expect(instance.arguments.size).to eq(1)
+        end
+
+        it 'should raise an error if invalid arguments is given' do
+          expect {
+            klass[:className].new 'i-dont-exist' => ''
+          }.to raise_error(Transmission::Arguments::InvalidArgument)
+        end
+      end
+    end
+  end
+
+  describe '.is_valid?' do
+    describe 'with valid key' do
+      it 'should return true' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Arguments.is_valid?('test_me')).to eq(true)
+      end
+    end
+
+    describe 'with invalid key' do
+      it 'should return true' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Arguments.is_valid?('testMee')).to eq(false)
+      end
+    end
+  end
+
+  describe '.real_key' do
+    describe 'with valid key' do
+      it 'should return real key' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Arguments.real_key('test_me')).to eq('test-me')
+      end
+    end
+
+    describe 'with invalid key' do
+      it 'should return nil' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Arguments.real_key('testMee')).to eq(nil)
+      end
+    end
+  end
+
+  describe '.filter' do
+    describe 'with valid keys' do
+      it 'should filter the correct keys' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        hash = { 'test-me' => 'some-value' }
+        expect(Transmission::Arguments.filter(hash)).to eq(hash)
+      end
+    end
+
+    describe 'with invalid keys' do
+      it 'should filter out the incorrect keys' do
+        stub_const('Transmission::Arguments::ATTRIBUTES', [{ field: 'test-me' }])
+        hash = { 'test-me' => 'some-value', 'incorrect-key' => 'some-value' }
+        expect(Transmission::Arguments.filter(hash)).to eq('test-me' => 'some-value')
+      end
+    end
+  end
+end

data/spec/transmission/fields_spec.rb

@@ -0,0 +1,60 @@
+describe Transmission::Fields do
+  [
+    { className: Transmission::Fields::SessionGet, fields: ['alt-speed-down'] },
+    { className: Transmission::Fields::TorrentGet, fields: ['doneDate'] },
+    { className: Transmission::Fields::SessionStats, fields: ['activeTorrentCount'] }
+  ].each do |klass|
+
+    describe klass[:className].to_s do
+      describe '#new' do
+        it 'should create an instance with correct fields' do
+          instance = klass[:className].new
+          expect(instance.fields.size).to eq(klass[:className]::ATTRIBUTES.size)
+        end
+
+        it 'should create an instance with given fields' do
+          instance = klass[:className].new klass[:fields]
+          expect(instance.fields.size).to eq(1)
+        end
+
+        it 'should raise an error if invalid arguments is given' do
+          expect {
+            klass[:className].new 'i-dont-exist' => ''
+          }.to raise_error(Transmission::Fields::InvalidField)
+        end
+      end
+    end
+  end
+
+  describe '.is_valid?' do
+    describe 'with valid key' do
+      it 'should return true' do
+        stub_const('Transmission::Fields::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Fields.is_valid?('test_me')).to eq(true)
+      end
+    end
+
+    describe 'with invalid key' do
+      it 'should return true' do
+        stub_const('Transmission::Fields::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Fields.is_valid?('testMee')).to eq(false)
+      end
+    end
+  end
+
+  describe '.real_key' do
+    describe 'with valid key' do
+      it 'should return real key' do
+        stub_const('Transmission::Fields::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Fields.real_key('test_me')).to eq('test-me')
+      end
+    end
+
+    describe 'with invalid key' do
+      it 'should return nil' do
+        stub_const('Transmission::Fields::ATTRIBUTES', [{ field: 'test-me' }])
+        expect(Transmission::Fields.real_key('testMee')).to eq(nil)
+      end
+    end
+  end
+end

data/spec/transmission/model/session_spec.rb

@@ -0,0 +1,85 @@
+describe Transmission::Model::Session do
+  describe '.get' do
+    describe 'with configuration' do
+      before :each do
+        Transmission::Config.set
+        stub_get_session(Transmission::Fields::SessionGet.new.to_fields)
+      end
+
+      it 'should return a session model' do
+        session = Transmission::Model::Session.get
+        expect(session).to be_a(Transmission::Model::Session)
+      end
+    end
+
+    describe 'with connector' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_session(Transmission::Fields::SessionGet.new.to_fields)
+      end
+
+      it 'should return an array of Torrent models' do
+        session = Transmission::Model::Session.get connector: @rpc
+        expect(session).to be_a(Transmission::Model::Session)
+      end
+    end
+  end
+
+  describe '#save!' do
+    let(:rpc) { Transmission::RPC.new }
+
+    before :each do
+      stub_const('Transmission::Arguments::SessionSet::ATTRIBUTES', [{ field: 'name' }])
+      stub_get_session(Transmission::Fields::SessionGet.new.to_fields)
+      stub_rpc_request
+        .with(body: session_set_body(name: 'new value'))
+        .to_return(successful_response)
+    end
+
+    it 'should send the right parameters' do
+      session = Transmission::Model::Session.get connector: rpc
+      session.name = 'new value'
+      session.save!
+    end
+  end
+
+  describe '#to_json' do
+    let(:session) { Transmission::Model::Session.new({ 'id' => 1 }, nil) }
+
+    it 'should return its attributes' do
+      expect(session.to_json).to eq('id' => 1)
+    end
+  end
+
+  describe '#method_missing' do
+    let(:session) { Transmission::Model::Session.new({ 'id' => 1, 'name' => 'some name', 'some-key' => 'some-value' }, nil) }
+
+    before :each do
+      stub_const('Transmission::Fields::SessionGet::ATTRIBUTES', [{ field: 'id' }, { field: 'name' }, { field: 'some-key' }])
+      stub_const('Transmission::Arguments::SessionSet::ATTRIBUTES', [{ field: 'name' }])
+    end
+
+    describe 'with existing attributes' do
+      it 'should return the correct values' do
+        expect(session.id).to eq(1)
+        expect(session.name).to eq('some name')
+        expect(session.some_key).to eq('some-value')
+      end
+
+      it 'should set the correct values' do
+        session.name = 'ok'
+        expect(session.name).to eq('ok')
+      end
+    end
+
+    describe 'with none existing attributes' do
+      it 'should raise error' do
+        expect { session.i_dont_exist }.to raise_error(NoMethodError)
+      end
+
+      it 'should raise error' do
+        expect { session.i_dont_exist = 'some value' }.to raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/transmission/model/torrent_spec.rb

@@ -0,0 +1,345 @@
+describe Transmission::Model::Torrent do
+  describe '.all' do
+    describe 'with configuration' do
+      before :each do
+        Transmission::Config.set
+        stub_get_torrent({}, [{ id: 1 }])
+      end
+
+      it 'should return a Torrent model instance' do
+        torrents = Transmission::Model::Torrent.all
+        expect(torrents).to be_a(Transmission::Model::Torrent)
+      end
+    end
+
+    describe 'with connector' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_rpc_request
+          .with(body: torrent_get_body)
+          .to_return(successful_response( arguments: { torrents: [{ id: 1 }] }))
+      end
+
+      it 'should return a Torrent model instance' do
+        torrents = Transmission::Model::Torrent.all connector: @rpc
+        expect(torrents).to be_a(Transmission::Model::Torrent)
+      end
+    end
+  end
+
+  describe '.find' do
+    describe 'with configuration' do
+      before :each do
+        Transmission::Config.set
+        stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+      end
+
+      it 'should return a Torrent instance' do
+        torrent = Transmission::Model::Torrent.find 1
+        expect(torrent).to be_a(Transmission::Model::Torrent)
+      end
+    end
+
+    describe 'with connector' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+      end
+
+      it 'should return a Torrent instance' do
+        torrent = Transmission::Model::Torrent.find 1, connector: @rpc
+        expect(torrent).to be_a(Transmission::Model::Torrent)
+      end
+    end
+
+    describe 'with invalid id' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_torrent({ ids: [1] }, [])
+      end
+
+      it 'should raise error' do
+        expect {
+          Transmission::Model::Torrent.find 1, connector: @rpc
+        }.to raise_error(Transmission::Model::Torrent::TorrentNotFoundError)
+      end
+    end
+
+    describe 'with multiple ids' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_torrent({ ids: [1, 2] }, [{ id: 1 }, { id: 2 }])
+      end
+
+      it 'should return a Torrent model instance' do
+        torrent = Transmission::Model::Torrent.find [1, 2], connector: @rpc
+        expect(torrent).to be_a(Transmission::Model::Torrent)
+      end
+
+      it 'should remember all ids' do
+        torrent = Transmission::Model::Torrent.find [1, 2], connector: @rpc
+        expect(torrent.ids).to eq([1, 2])
+      end
+    end
+  end
+
+  describe '.add' do
+    describe 'with configuration' do
+      before :each do
+        Transmission::Config.set
+        stub_rpc_request
+          .with(body: torrent_add_body(filename: 'torrent_file'))
+          .to_return(successful_response(arguments: { 'torrent-added' => { id: 1 } }))
+        stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+      end
+
+      it 'should return a Torrent instance' do
+        torrent = Transmission::Model::Torrent.add arguments: { filename: 'torrent_file' }
+        expect(torrent).to be_a(Transmission::Model::Torrent)
+      end
+    end
+
+    describe 'when torrent is a duplicate' do
+      before :each do
+        Transmission::Config.set
+        stub_rpc_request
+          .with(body: torrent_add_body(filename: 'torrent_file'))
+          .to_return(unsuccessful_response(result: 'duplicate torrent'))
+      end
+
+      it 'should raise error' do
+        expect {
+          Transmission::Model::Torrent.add arguments: { filename: 'torrent_file' }
+        }.to raise_error(Transmission::RPC::Connector::ConnectionError)
+      end
+    end
+  end
+
+  describe '.start_all!' do
+    before :each do
+      Transmission::Config.set
+      stub_rpc_request
+        .with(body: torrent_method_body('torrent-start', {}))
+        .to_return(successful_response)
+    end
+
+    it 'should start all torrents' do
+      Transmission::Model::Torrent.start_all!
+    end
+  end
+
+  describe '.stop_all!' do
+    before :each do
+      Transmission::Config.set
+      stub_rpc_request
+        .with(body: torrent_method_body('torrent-stop', {}))
+        .to_return(successful_response)
+    end
+
+    it 'should start all torrents' do
+      Transmission::Model::Torrent.stop_all!
+    end
+  end
+
+  describe '#set_location' do
+    before :each do
+      Transmission::Config.set
+      stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+      stub_set_location_torrent(location: '/some/location', move: false, ids: [1])
+    end
+
+    it 'should set a new location' do
+      torrent = Transmission::Model::Torrent.find 1
+      torrent.set_location '/some/location'
+    end
+  end
+
+  describe '#delete!' do
+    describe 'with configuration' do
+      before :each do
+        Transmission::Config.set
+        stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+        stub_rpc_request
+          .with(body: torrent_remove_body(:ids => [1], 'delete-local-data' => false))
+          .to_return(successful_response(arguments: { torrents: [{ id: 1 }] }))
+      end
+
+      it 'should remove the torrent file' do
+        torrent = Transmission::Model::Torrent.find 1
+        torrent.delete!
+        expect(torrent.deleted).to eq(true)
+      end
+    end
+
+    describe 'with connector' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_torrent({ ids: [1] }, [{ id: 1 }])
+        stub_rpc_request
+          .with(body: torrent_remove_body(:ids => [1], 'delete-local-data' => false))
+          .to_return(successful_response(arguments: { torrents: [{ id: 1 }] }))
+      end
+
+      it 'should remove the torrent file' do
+        torrent = Transmission::Model::Torrent.find 1, connector: @rpc
+        torrent.delete!
+        expect(torrent.deleted).to eq(true)
+      end
+    end
+
+    describe 'with multiple ids' do
+      before :each do
+        @rpc = Transmission::RPC.new
+        stub_get_torrent({ ids: [1, 2] }, [{ id: 1 }, { id: 2 }])
+        stub_rpc_request
+          .with(body: torrent_remove_body(:ids => [1, 2], 'delete-local-data' => false))
+            .to_return(successful_response(arguments: { torrents: [{ id: 1 }, { id: 2 }]} ))
+      end
+
+      it 'should remove the torrent files' do
+        torrent = Transmission::Model::Torrent.find [1, 2], connector: @rpc
+        torrent.delete!
+        expect(torrent.deleted).to eq(true)
+      end
+    end
+  end
+
+  describe '#is_multi?' do
+    let(:torrents) { Transmission::Model::Torrent.new([{'id' => 1}, {'id' => 2}], nil) }
+    let(:torrent) { Transmission::Model::Torrent.new([{'id' => 1}], nil) }
+
+    describe 'with multiple torrents' do
+      it 'should return true' do
+        expect(torrents.is_multi?).to eq(true)
+      end
+    end
+
+    describe 'with single torrent' do
+      it 'should return false' do
+        expect(torrent.is_multi?).to eq(false)
+      end
+    end
+  end
+
+  describe '#to_json' do
+    let(:torrents) { Transmission::Model::Torrent.new([{ 'id' => 1 }, { 'id' => 2 }], nil) }
+    let(:torrent) { Transmission::Model::Torrent.new([{ 'id' => 1 }], nil) }
+
+    describe 'with multiple torrents' do
+      it 'should return true' do
+        expect(torrents.to_json).to eq([{ 'id' => 1 }, { 'id' => 2 }])
+      end
+    end
+
+    describe 'with single torrent' do
+      it 'should return false' do
+        expect(torrent.to_json).to eq({ 'id' => 1 })
+      end
+    end
+  end
+
+  describe '#completed?' do
+    let(:completed_torrent) { Transmission::Model::Torrent.new([{ 'id' => 1, 'percentDone' => 1 }], nil) }
+    let(:incomplete_torrent) { Transmission::Model::Torrent.new([{ 'id' => 1, 'percentDone' => 0.5 }], nil) }
+
+    describe 'with completed torrent' do
+      it 'should return true' do
+        expect(completed_torrent.completed?).to eq(true)
+      end
+    end
+
+    describe 'with unfinished torrent' do
+      it 'should return false' do
+        expect(incomplete_torrent.completed?).to eq(false)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:torrent) { Transmission::Model::Torrent.new([{'id' => 1, 'name' => 'some name', 'some-key' => 'some-value'}], nil) }
+
+    before :each do
+      stub_const("Transmission::Fields::TorrentGet::ATTRIBUTES", [{field: 'id'}, {field: 'name'}, {field: 'some-key'}])
+      stub_const("Transmission::Arguments::TorrentSet::ATTRIBUTES", [{field: 'name'}])
+    end
+
+    describe 'with existing attributes' do
+      it 'should return the correct values' do
+        expect(torrent.id).to eq(1)
+        expect(torrent.name).to eq('some name')
+        expect(torrent.some_key).to eq('some-value')
+      end
+
+      it 'should set the correct values' do
+        torrent.name = 'ok'
+        expect(torrent.name).to eq('ok')
+      end
+    end
+
+    describe 'with none existing attributes' do
+      it 'should raise error' do
+        expect {
+          torrent.i_dont_exist
+        }.to raise_error(NoMethodError)
+      end
+
+      it 'should raise error' do
+        expect {
+          torrent.i_dont_exist = 'some value'
+        }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe '#save!' do
+    let(:rpc) {Transmission::RPC.new}
+
+    before :each do
+      stub_const("Transmission::Arguments::TorrentSet::ATTRIBUTES", [{field: 'name'}, {field: 'ids'}])
+      stub_get_torrent({ids: [1]}, [{id: 1, name: 'test', comment: 'comment'}])
+      stub_rpc_request
+          .with(body: torrent_set_body({name: 'new value', ids: [1]}))
+          .to_return(successful_response)
+    end
+
+    it 'should send the right parameters' do
+      torrent = Transmission::Model::Torrent.find 1, connector: rpc
+      torrent.name = 'new value'
+      torrent.save!
+    end
+  end
+
+  [
+      {method: 'start!', rpc_method: 'torrent-start'},
+      {method: 'start_now!', rpc_method: 'torrent-start-now'},
+      {method: 'stop!', rpc_method: 'torrent-stop'},
+      {method: 'verify!', rpc_method: 'torrent-verify'},
+      {method: 're_announce!', rpc_method: 'torrent-reannounce'},
+      {method: 'move_up!', rpc_method: 'queue-move-up'},
+      {method: 'move_down!', rpc_method: 'queue-move-down'},
+      {method: 'move_top!', rpc_method: 'queue-move-top'},
+      {method: 'move_bottom!', rpc_method: 'queue-move-bottom'}
+  ].each do |object|
+    describe "##{object[:method]}" do
+      let(:rpc) {Transmission::RPC.new}
+
+      [
+          {ids: [1], response: [{id: 1}], text: ''},
+          {ids: [1, 2], response: [{id: 1}, {id: 2}], text: 'with multiple ids'}
+      ].each do |args|
+        before :each do
+          stub_get_torrent({ids: args[:ids]}, args[:response])
+          stub_rpc_request
+              .with(body: torrent_method_body(object[:rpc_method], {ids: args[:ids]}))
+              .to_return(successful_response)
+        end
+
+        it "should #{object[:method]} torrent #{args[:text]}" do
+          torrent = Transmission::Model::Torrent.find args[:ids], connector: rpc
+          torrent.send object[:method].to_sym
+        end
+      end
+    end
+  end
+
+end