junkie 0.0.1 → 0.0.2

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+ - 1.9.3
+

data/Gemfile

@@ -1,4 +1,8 @@
 source 'https://rubygems.org'
 
+gem 'rake'
+gem 'webmock'
+gem 'rspec'
+
 # Specify your gem's dependencies in junkie.gemspec
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# Junkie
+# Junkie [![Build Status](https://secure.travis-ci.org/pboehm/junkie.png?branch=master)](https://travis-ci.org/pboehm/junkie)
 
 TV series management application that includes the whole lifecycle for new
 episodes. `junkie` does the following things:

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/junkie

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+# encoding: UTF-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'junkie'
+include Junkie
+
+start_reactor

data/junkie.gemspec

@@ -16,4 +16,13 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.add_runtime_dependency(%q<eventmachine>, [">= 1.0"])
+  gem.add_runtime_dependency(%q<em-http-request>, [">= 1.0"])
+  gem.add_runtime_dependency(%q<yajl-ruby>, ["~> 1.1.0"])
+  gem.add_runtime_dependency(%q<nokogiri>, [">= 1.5"])
+  gem.add_runtime_dependency(%q<hashconfig>, [">= 0.0.1"])
+  gem.add_runtime_dependency(%q<serienrenamer>, [">= 0.0.1"])
+  gem.add_runtime_dependency(%q<sjunkieex>, [">= 0.0.1"])
+  gem.add_runtime_dependency(%q<sindex>, [">= 0.0.1"])
+  gem.add_runtime_dependency(%q<logging>, ["~> 1.8.0"])
 end

data/lib/junkie/config.rb

@@ -0,0 +1,75 @@
+require 'hashconfig'
+require 'fileutils'
+
+module Junkie
+
+  # Module that encapsulates the handling for configuration into a module
+  # which can be included into any Class which includes a constant Hash named
+  # DEFAULT_CONFIG is returned by Config.get_config(self) merged with the
+  # version from the config file
+  #
+  # @example
+  #   class Foo
+  #     include Config
+  #
+  #     DEFAULT_CONFIG = { refresh: 5 }
+  #
+  #     def initialize
+  #       # the following holds the merged version from DEFAULT_CONFIG
+  #       @config = Config.get_config(self)
+  #     end
+  #   end
+  #
+  module Config
+    @including_classes = []
+    @comlete_config = nil
+
+    # Callback method which is called when a class includes the module
+    #
+    # @param [Class] the class which includes the module
+    def self.included(mod)
+      @including_classes << mod
+    end
+
+
+    # Get the config hash for the calling module merged with the hash from the
+    # config file
+    #
+    # @param [Class] should be equal to `self`
+    # @return [Hash] merged version of DEFAULT_CONFIG from the calling class
+    def self.get_config(source)
+
+      # builds up the complete config and merges them with serialzed version
+      # at the first call to this method
+      if @comlete_config.nil?
+        default_config = self.collect_default_configs
+
+        FileUtils.mkdir_p File.dirname(Junkie::CONFIG_FILE)
+        @comlete_config =
+          default_config.merge_with_serialized(Junkie::CONFIG_FILE)
+      end
+
+      return @comlete_config[source.class.to_s]
+    end
+
+
+    # Collects the DEFAULT_CONFIG from all including Classes
+    #
+    # @return [Hash] hash of hashes indexed by class name
+    def self.collect_default_configs
+      config = Hash.new
+
+      @including_classes.each do |klass|
+        if not klass.const_defined? :DEFAULT_CONFIG
+          raise NotImplementedError,
+            "#{klass} has to include a constant DEFAULT_CONFIG as Hash"
+        end
+
+        config[klass.to_s] = klass.const_get :DEFAULT_CONFIG
+      end
+
+      config
+    end
+
+  end
+end

data/lib/junkie/episode.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Junkie
+
+  require 'sindex'
+
+  class Episode
+    attr_reader :id, :series, :found_at, :link
+    attr_accessor :description, :status
+
+    def initialize(series, link, description=nil)
+      @series = series
+      @link = link
+      @found_at = DateTime.now
+      @description = description
+      @status = :found
+      @id = episode_identifier
+    end
+
+    def to_s
+      "%s (%s)" % [ @series, episode_identifier ]
+    end
+
+    private
+
+    def episode_identifier
+      Sindex::SeriesIndex.extract_episode_identifier(@description)
+    end
+
+  end
+end

data/lib/junkie/errors.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Junkie
+  class InvalidCredentialsError < Exception;  end
+
+  class HTTP403Error < Exception;  end
+  class HTTP404Error < Exception;  end
+  class HTTP500Error < Exception;  end
+
+  class InvalidConfigError < Exception;  end
+
+  class InvalidStateError < Exception;  end
+end

data/lib/junkie/helper.rb

@@ -0,0 +1,13 @@
+require 'fiber'
+
+module Junkie
+  module Helper
+
+    def in_fiber(&block)
+      Fiber.new {
+        block.call
+      }.resume
+    end
+
+  end
+end

data/lib/junkie/log.rb

@@ -0,0 +1,16 @@
+require 'logging'
+
+module Junkie
+
+  # Utility module that includes a logging function `log` into the class
+  # that includes this mdoule
+  module Log
+
+    # constructs a new Logger for the class
+    #
+    # @return [Logging.logger] returns a Logger instance for the current class
+    def log
+      @log ||= Logging.logger[self]
+    end
+  end
+end

data/lib/junkie/patched/sjunkieex.rb

@@ -0,0 +1,79 @@
+require 'em-http'
+require 'fiber'
+require 'junkie/log'
+require 'sjunkieex'
+
+module Junkie
+
+  # Monkex-patched version of the Interface from the `sjunkieex` gem
+  class ::Sjunkieex::Interface
+    include Junkie::Log
+
+
+    # Method that searches for new episodes and returns it in a nice structure
+    #
+    # @note should be called inside a Ruby fiber
+    # @return [Hash] series names as keys, data as values
+    def get_links_for_downloads
+      episodes = []
+      look_for_new_episodes.each do |link,series|
+
+        links = parse_series_page(series, link)
+        links.each do |identifier, link_data|
+
+          hd = @options[:hd_enabled]
+
+          # select links, depending on wanted resolution
+          links = []
+          if hd
+              if link_data[:hd_1080p]
+                  links = link_data[:hd_1080p]
+              elsif link_data[:hd_720p]
+                  links = link_data[:hd_720p]
+              end
+          else
+            (links = link_data[:sd]) if link_data[:sd]
+          end
+
+          if links.empty?
+              log.info("#{series}(#{identifier}) no links in this resolution")
+              next
+          end
+
+          download_links = links.select do |link|
+              link.match(/\/f-\w+\/#{ @options[:hoster_id] }_/)
+          end
+
+          if download_links.empty?
+              puts "there are no links for this hoster"
+              next
+          end
+
+          episode = Junkie::Episode.new(
+              series, download_links.first, link_data[:episodedata])
+          episodes << episode
+        end
+      end
+
+      episodes
+    end
+
+    private
+
+    def get_page_data(link)
+      f = Fiber.current
+        http = EventMachine::HttpRequest.new(link).get :timeout => 10
+
+        http.callback { f.resume(http) }
+        http.errback  { f.resume(http) }
+
+        Fiber.yield
+
+        if http.error
+          raise IOError, http.error
+        end
+
+        http.response
+    end
+  end
+end

data/lib/junkie/pyload/api.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+require 'em-http'
+require 'em-http/middleware/json_response'
+require 'yaml'
+require 'json'
+require 'uri'
+
+module Junkie
+  module Pyload
+
+    # Class that abstracts the Pyload Api
+    class Api
+      include Config
+
+      attr_reader :config, :cookie
+
+      FILE_STATUS = {
+        0  => :done,
+        2  => :online,
+        3  => :queued,
+        4  => :skipped,
+        5  => :waiting,
+        8  => :failed,
+        10 => :decrypting,
+        12 => :downloading,
+        13 => :extracting,
+      }
+
+      DEFAULT_CONFIG = {
+        protocol: 'http',
+        host: 'localhost',
+        port: 8000,
+        api_user: '',
+        api_password: ''
+      }
+
+      def initialize()
+        @config = Config.get_config(self)
+
+        api_user     = @config[:api_user]
+        api_password = @config[:api_password]
+
+        unless api_password && api_user &&
+                  api_password.match(/\w+/) && api_user.match(/\w+/)
+          raise InvalidConfigError, "api_user or api_password are not configured"
+        end
+
+      end
+
+      # makes a GET request with the given method name and params
+      #
+      # @param [Symbol] API-method e.g :getQueue, :getPackageData
+      # @param [Hash] params that are a passed as query parameters
+      #
+      # @return [Object] parsed JSON Response
+      def call(method, params={})
+        raise ArgumentError, "`method` is not a Symbol" unless method.is_a? Symbol
+
+        query_parameter = {}
+        params.each do |key, value|
+          if value.is_a? Array
+            query_parameter[key] =
+              URI.encode_www_form_component(JSON.dump(value))
+          else
+            query_parameter[key] =
+              URI.encode_www_form_component('"' + value.to_s + '"')
+          end
+        end
+
+        request("/#{method.to_s}", :get, query_parameter)
+      end
+
+
+      # Logs the api user in through sending the credentials to the Api
+      #
+      # @note sets cookie instance variable
+      # @raise [Junkie::InvalidCredentialsError] is raised when the Login fails
+      def login
+        resp = nil
+
+        begin
+          resp = request('/login', :post, {
+                username: @config[:api_user],
+                password: @config[:api_password]
+          }, true)
+
+        rescue Junkie::HTTP403Error => e
+          raise Junkie::InvalidCredentialsError,
+            "the supplied credentials are incorrect"
+        end
+
+        # extract Cookie-ID from Login response
+        if resp.response_header["SET_COOKIE"]
+          header = resp.response_header["SET_COOKIE"]
+          if md = header.match(/^(\S+);/)
+             @cookie = md[1]
+          end
+        end
+      end
+
+      # builds up a URL string
+      #
+      # @param [String] path the method specific part of the url
+      # @return [String] complete URI String
+      def build_url(path="")
+        "%s://%s:%d/api%s" %
+            [ @config[:protocol], @config[:host], @config[:port], path ]
+      end
+
+      private
+
+
+      # Utility function for making requests
+      #
+      # @param [String] method specific path e.g /getConfig or /login
+      # @param [Symbol] HTTP method that is issued :get, :post, :delete
+      # @param [Hash] Params that are added to the request, as query parameter
+      # on :get requests and body on :post requests
+      # @param [Boolean] return full response instead of body
+      #
+      # @return [Object] JSON Object that is send from the server or complete
+      # response if the previous argument is set
+      def request(path, method=:get, params={}, complete=false)
+        f = Fiber.current
+
+        request_options = {}
+        if method == :get
+          request_options[:query] = params
+        elsif method == :post
+          request_options[:body] = params
+        end
+
+        if @cookie
+          request_options[:head] = {'cookie' => @cookie}
+        end
+
+        conn = EventMachine::HttpRequest.new(build_url(path))
+        conn.use EventMachine::Middleware::JSONResponse
+
+        http = conn.method(method).call request_options
+
+        http.callback { f.resume(http) }
+        http.errback  { f.resume(http) }
+
+        Fiber.yield
+
+        case http.response_header.status
+        when 403
+          raise Junkie::HTTP403Error, "Response has status code 403"
+        when 404
+          raise Junkie::HTTP404Error, "Response has status code 404"
+        when 500
+          raise Junkie::HTTP500Error, "Response has status code 505"
+        end
+
+        return http if complete
+        http.response
+      end
+    end
+  end
+end

data/lib/junkie/pyload/observer.rb

@@ -0,0 +1,197 @@
+# encoding: utf-8
+require 'junkie/helper'
+require 'yaml'
+
+module Junkie
+  module Pyload
+    class Observer
+      include Log, Helper, Config
+
+      DEFAULT_CONFIG = {
+          watchdog_refresh: 10,          # interval the watchdog_timer is fired
+      }
+
+      def initialize(config={})
+        @config = Config.get_config(self)
+
+        @api = Junkie::Pyload::Api.new
+
+        @ready_for_new_links = true
+        @watchdog = nil
+        @active_downloads = Hash.new
+      end
+
+      # is a method that is called once from inside the reactor and allows us
+      # to register custom actions into the reactor
+      def setup
+        in_fiber {
+          @api.login
+          cleanup
+        }
+      end
+
+      # Adds new episode to Pyload which downloads the episode and extracts it
+      #
+      # @param [Junkie::Episode] episode which should be downloaded
+      #
+      # @note should only be called if `is_ready?` returns true
+      def add_episode(episode)
+        raise InvalidStateError, "Observer is not ready" unless is_ready?
+        @ready_for_new_links = false
+
+        episode.status = :downloading
+
+        package = "%s@%s" % [ episode.id, episode.series ]
+
+        pid = @api.call(:addPackage, {name: package, links: [episode.link]})
+
+        @active_downloads[pid] = episode
+
+        log.info("Added #{episode} to Pyload, Pid=#{pid}")
+
+        # start watchdog timer if it does not already run
+        if @watchdog.nil?
+          @watchdog = EM::PeriodicTimer.new(@config[:watchdog_refresh]) do
+            monitor_progress
+          end
+        end
+      end
+
+      # checks if the Observer is ready to add new episodes to Pyload
+      #
+      # @returns [Boolean] true if new links can be added
+      def is_ready?
+        @ready_for_new_links
+      end
+
+      private
+
+      # This method is called from the watchdog timer periodically
+      #
+      # It monitors the download process and reacts depending on the results
+      def monitor_progress
+        log.debug("Watchdog timer has been fired")
+
+        in_fiber {
+          catch(:break) {
+            queue_data = @api.call(:getQueueData)
+
+            if queue_data.empty?
+              log.info("Empty Pyload queue, I cancel the watchdog timer")
+              unschedule_watchdog
+              throw :break
+            end
+
+            # extract package IDs and map them to current downloads
+            update_package_ids(queue_data)
+
+            if has_queue_any_failed_links?(queue_data)
+              log.info("There are failed links in the Queue, will fix this")
+              @api.call(:restartFailed)
+              throw :break
+            end
+
+            # look for complete downloads
+            pids = get_complete_downloads(queue_data)
+
+            if not pids.empty?
+              @api.call(:deletePackages, {pids: pids})
+              log.info("Complete packages are removed from Pyload Queue")
+
+              @ready_for_new_links = true
+            end
+          }
+        }
+      end
+
+      # Searches for failed links in the pyload queue
+      #
+      # @param [Array] queue_data returned from :getQueueData api method
+      #
+      # @return [Boolean] true if there are any failed links, false otherwise
+      def has_queue_any_failed_links?(queue_data)
+        queue_data.each do |package|
+          package['links'].each do |link|
+            status = Pyload::Api::FILE_STATUS[link['status']]
+            return true if status == :failed
+          end
+        end
+
+        false
+      end
+
+      # Looks for complete downloads and returns their pids
+      #
+      # @param [Array] queue_data returned from :getQueueData api method
+      #
+      # @return [Array] list of pids there the download is complete
+      def get_complete_downloads(queue_data)
+        pids = []
+        queue_data.each do |package|
+          next unless package['links'].size > 0
+
+          next if package['linksdone'] == 0
+
+          # When extracting is in progress the status of the first link is set
+          # to :extracting
+          extracting = package['links'].select do |link|
+            Pyload::Api::FILE_STATUS[link['status']] == :extracting
+          end
+          next unless extracting.empty?
+
+          sizetotal = package['sizetotal'].to_i
+          sizedone = package['sizedone'].to_i
+
+          if sizetotal > 0 && sizedone > 0
+
+            if sizetotal == sizedone
+              pids << package['pid']
+            end
+          end
+        end
+
+        pids
+      end
+
+      # extract package IDs and map them to current downloads
+      #
+      # @param [Array] queue_data returned from :getQueueData api method
+      def update_package_ids(queue_data)
+        queue_data.each do |package|
+          pid = package['pid']
+          next if @active_downloads.has_key? pid
+
+          if @active_downloads.has_key? pid-1
+            log.info("Package ID has been changed, I will correct this")
+            @active_downloads[pid] = @active_downloads[pid-1]
+            @active_downloads.delete(pid-1)
+            next
+          end
+
+          raise InvalidStateError,
+            "PackageID #{pid} can't be mapped to active Download"
+        end
+      end
+
+      # cancels the watchdog timer
+      def unschedule_watchdog
+        if @watchdog_timer
+          @watchdog_timer.cancel
+        end
+      end
+
+      def cleanup
+        log.debug("Made a cleanup of Pyload's Queue")
+        @api.call(:stopAllDownloads)
+
+        packages = @api.call(:getQueue).map { |e| e['pid'] }
+
+        @api.call(:deletePackages, {pids: packages})
+        log.debug("The following packages have been removed: #{packages}")
+
+        @api.call(:unpauseServer)
+      end
+
+    end
+  end
+end

data/lib/junkie/reactor.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+require 'sindex'
+require 'sjunkieex'
+require 'eventmachine'
+require 'fiber'
+require 'yaml'
+require 'junkie'
+require 'junkie/pyload/api'
+require 'junkie/pyload/observer'
+require 'junkie/errors'
+
+module Junkie
+
+  class Reactor
+    include Log, Helper, Config
+
+    DEFAULT_CONFIG = {
+      :hd_enabled         => false,
+      :hoster_id          => "ul",
+      :series_index_file  => File.join(Dir.home, '.sindex/seriesindex.xml'),
+      :episode_queue_timer_refresh => 5,  # in seconds
+      :episode_search_refresh      => 15, # in minutes
+    }
+
+
+    def initialize
+      @config = Config.get_config(self)
+
+      @sindex = Sindex::SeriesIndex.new(index_file: @config[:series_index_file])
+      @sjunkieex = Sjunkieex::Interface.new(@sindex, @config)
+      @pyload_observer = Junkie::Pyload::Observer.new()
+
+      @episode_queue = EM::Queue.new
+      @found_episodes = Hash.new
+      build_procs # has to be called here
+    end
+
+    def build_procs
+
+      # Proc that looks for new episodes on Seriesjunkies.org and adds them to
+      # the episode_queue if they are new
+      @look_for_new_episodes = Proc.new {
+        in_fiber {
+          log.info "Looking for new episodes"
+
+          @sjunkieex.get_links_for_downloads.each do |episode|
+            identifier = "%s@%s" % [episode.id, episode.series]
+
+            if not @found_episodes.has_key? identifier
+              log.info("Found new episode '#{episode}'")
+              @episode_queue.push(episode)
+              @found_episodes[identifier] = episode
+            end
+          end
+        }
+      }
+
+      # Proc that checks is Pyload-Observer is ready for new episodes and the
+      # episode_queue contains new episodes.
+      #
+      # @note Is called from within the reactor
+      @add_episodes_to_pyload = Proc.new do
+        if @pyload_observer.is_ready?
+          @episode_queue.pop do |episode|
+            log.info("Popped episode '#{episode}' from queue")
+            in_fiber {
+              @pyload_observer.add_episode(episode)
+            }
+          end
+        end
+      end
+    end
+
+    ###########################################################################
+    #################### The Reactor ##########################################
+    ###########################################################################
+    def start
+      log.info("Starting Junkie #{Junkie::VERSION}")
+
+      EM.run do
+
+        # do some initialization work
+        @pyload_observer.setup
+
+        # Look for new episodes and add them to the Queue if they haven't
+        # been found yet
+        EM.next_tick do
+          @look_for_new_episodes.call
+
+          EM.add_periodic_timer(@config[:episode_search_refresh] * 60) do
+            @look_for_new_episodes.call
+          end
+        end
+
+        # Add found episodes into Pyload if there are any episodes and pyload
+        # is ready
+        EM.add_periodic_timer(
+          @config[:episode_queue_timer_refresh], @add_episodes_to_pyload)
+
+        # for determining blocking operations
+        # EM.add_periodic_timer(1) { puts Time.now.to_i }
+      end
+    end
+  end
+end

data/lib/junkie/version.rb

@@ -1,3 +1,3 @@
 module Junkie
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/junkie.rb

@@ -1,5 +1,24 @@
-require "junkie/version"
+require 'junkie/version'
+require 'junkie/config'
+require 'junkie/episode'
+require 'junkie/log'
+require 'junkie/reactor'
+require 'junkie/errors'
+require 'junkie/helper'
+require 'junkie/patched/sjunkieex'
+require 'junkie/pyload/api'
+require 'junkie/pyload/observer'
+require 'logging'
+
+Logging.logger.root.appenders = Logging.appenders.stdout
+Logging.logger.root.level = :debug
 
 module Junkie
-  # Your code goes here...
+
+  CONFIG_FILE = File.join(Dir.home, '.junkie', 'config.yml')
+
+  def start_reactor
+    r = Reactor.new
+    r.start
+  end
 end

data/spec/config_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'fileutils'
+
+class ConfigTest
+  include Junkie::Config
+
+  attr_reader :config
+
+  DEFAULT_CONFIG = {
+    refresh: 5,
+    numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+  }
+
+  def initialize()
+    @config = Junkie::Config.get_config(self)
+  end
+end
+
+describe ConfigTest do
+
+  before do
+    @file = '/tmp/testtest.yml'
+    stub_const("Junkie::CONFIG_FILE", @file)
+  end
+
+  after(:each) do
+    FileUtils.rm(@file) if File.file? @file
+  end
+
+  it "should stub out the Config File" do
+    expect(Junkie::CONFIG_FILE).to eq('/tmp/testtest.yml')
+  end
+
+  it "should return the default if there are no changes made" do
+    test = ConfigTest.new
+    expect(test.config).to eq ConfigTest::DEFAULT_CONFIG
+  end
+
+end

data/spec/environment_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe Junkie do
+  it "should compute the right thing" do
+    (1+2).should eq 3
+  end
+end

data/spec/pyload_api_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'yaml'
+
+# WebMock.disable_net_connect!
+
+describe Junkie::Pyload::Api do
+  include EMHelper
+
+  # remove the Config module behaviour
+  before(:each) do
+    Junkie::Config.stub!(:get_config).and_return(
+      Junkie::Pyload::Api::DEFAULT_CONFIG.merge(
+        {api_user: 'user', api_password: 'pass'}))
+  end
+
+  context "standard configuration" do
+
+    before(:each) do
+      @api = Junkie::Pyload::Api.new()
+    end
+
+    it "should have the right standard url" do
+      expect(@api.build_url).to eq "http://localhost:8000/api"
+    end
+
+  end
+
+  context "#login" do
+
+    context "valid credentials" do
+
+      before(:each) do
+        @api = Junkie::Pyload::Api.new()
+        @stub = stub_request(:post, "http://localhost:8000/api/login").
+          with(:body => "username=user&password=pass").
+          to_return(:status => 200, :body => "",
+                    :headers => {SET_COOKIE: "api.id=123456; valid until it is removed"})
+      end
+
+      it "should use the right url for API login" do
+        em {
+          @api.login
+          @stub.should have_been_requested
+        }
+      end
+
+      it "should extract the Cookie from the login response" do
+        em {
+          @api.login
+          expect(@api.cookie).to eq "api.id=123456"
+        }
+      end
+    end
+
+    context "invalid credentials" do
+
+      before(:each) do
+        @api = Junkie::Pyload::Api.new()
+        @api.config[:api_password] = "invalid"
+        @stub = stub_request(:post, "http://localhost:8000/api/login").
+          with(:body => "username=user&password=invalid").
+          to_return(:status => 403, :body => "", :headers => {})
+      end
+
+      it "should raise an error if login does not work" do
+        em {
+          expect {
+            @api.login
+          }.to raise_error(Junkie::InvalidCredentialsError)
+        }
+      end
+
+    end
+  end
+
+  context "#call" do
+
+    before(:each) do
+        @api = Junkie::Pyload::Api.new()
+        @api.stub(:cookie).and_return("api.id=123456")
+    end
+
+    it "should call the right url for the method name" do
+      em {
+        stub = stub_request(:get, "http://localhost:8000/api/getQueue")
+        @api.call(:getQueue)
+        stub.should have_been_requested
+      }
+    end
+
+    it "should pass parameters as JSON to the Request" do
+      em {
+        stub_request(:get, "http://localhost:8000/api/addPackage?links=%255B%2522http%253A%252F%252Ftest.test.de%2522%255D&name=%2522testpkg%2522").
+          to_return(:status => 200, :body => "76",
+                    :headers => {"Content-Type" => "application/json"})
+
+        res = @api.call(:addPackage, { name: "testpkg", links: [ "http://test.test.de" ]})
+        res.should eq 76
+      }
+    end
+
+    it "should build ruby datatypes from the JSON" do
+      em {
+        stub_request(:get, "http://localhost:8000/api/statusServer").
+          to_return(:status => 200, :body => '{ "pause": false, "total": 141 }',
+                    :headers => {"Content-Type" => "application/json"})
+
+        res = @api.call(:statusServer)
+        hash = { "pause" => false, "total" => 141 }
+        res.should eq hash
+      }
+
+    end
+  end
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../lib/junkie'
+
+require 'bundler/setup'
+require 'rspec'
+require 'eventmachine'
+require 'fiber'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+end
+
+# Helper module that can be included into test cases
+module EMHelper
+
+  # wraps a given block in a EM event loop and a fiber
+  #
+  # @param [Block] block which is called inside an event loop and a fiber
+  def em(&block)
+    EM.run do
+      Fiber.new do
+        block.call
+
+        EM.stop
+      end.resume
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: junkie
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,184 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
-dependencies: []
+date: 2012-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: hashconfig
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: serienrenamer
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: sjunkieex
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: sindex
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
 description: TV series management application
 email:
 - philipp-boehm@live.de
-executables: []
+executables:
+- junkie
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/junkie
 - junkie.gemspec
 - lib/junkie.rb
+- lib/junkie/config.rb
+- lib/junkie/episode.rb
+- lib/junkie/errors.rb
+- lib/junkie/helper.rb
+- lib/junkie/log.rb
+- lib/junkie/patched/sjunkieex.rb
+- lib/junkie/pyload/api.rb
+- lib/junkie/pyload/observer.rb
+- lib/junkie/reactor.rb
 - lib/junkie/version.rb
+- spec/config_spec.rb
+- spec/environment_spec.rb
+- spec/pyload_api_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/pboehm/junkie
 licenses: []
 post_install_message: 
@@ -50,4 +211,9 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: TV series managament tool that does all the work you have with your series.
-test_files: []
+test_files:
+- spec/config_spec.rb
+- spec/environment_spec.rb
+- spec/pyload_api_spec.rb
+- spec/spec_helper.rb
+has_rdoc: