tivohmo 0.1.0

data/spec/adapters/plex/season_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Season do
+
+  let(:plex_delegate) { plex_stub(::Plex::Season) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      season = described_class.new(plex_delegate)
+      expect(season).to be_a described_class
+      expect(season).to be_a TivoHMO::API::Container
+      expect(season.title).to eq(plex_delegate.title)
+      expect(season.identifier).to eq(plex_delegate.key)
+      # expect(app.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      # expect(app.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+end

data/spec/adapters/plex/section_spec.rb

@@ -0,0 +1,38 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Section do
+
+  let(:plex_delegate) { plex_stub(::Plex::Section) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      section = described_class.new(plex_delegate)
+      expect(section).to be_a described_class
+      expect(section).to be_a TivoHMO::API::Container
+      expect(section.title).to eq(plex_delegate.title)
+      expect(section.identifier).to eq(plex_delegate.key)
+      expect(section.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(section.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+  describe "#children" do
+
+    it "should memoize" do
+      section = described_class.new(plex_delegate)
+      expect(section.children.object_id).to eq(section.children.object_id)
+    end
+
+    it "should have category children" do
+      section = described_class.new(plex_delegate)
+      expect(section.children.size).to eq(11)
+      classes = [TivoHMO::Adapters::Plex::Category, TivoHMO::Adapters::Plex::QualifiedCategory]
+      expect(section.children.collect(&:class).uniq).to eq(classes)
+    end
+
+  end
+
+end

data/spec/adapters/plex/show_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Show do
+
+  let(:plex_delegate) { plex_stub(::Plex::Show) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      show = described_class.new(plex_delegate)
+      expect(show).to be_a described_class
+      expect(show).to be_a TivoHMO::API::Container
+      expect(show.title).to eq(plex_delegate.title)
+      expect(show.identifier).to eq(plex_delegate.key)
+      expect(show.modified_at).to eq(Time.at(plex_delegate.updated_at))
+      expect(show.created_at).to eq(Time.at(plex_delegate.added_at))
+    end
+
+  end
+
+end

data/spec/adapters/plex/transcoder_spec.rb

@@ -0,0 +1,27 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/plex'
+
+describe TivoHMO::Adapters::Plex::Transcoder do
+
+
+  let(:plex_delegate) { plex_stub(::Plex::Movie,
+                                  summary: 'Summary',
+                                  duration: 10000,
+                                  medias: [double('media',
+                                                 parts: [double('part',
+                                                                file: '/foo')])])}
+
+  let(:item) { double('item', identifier: plex_delegate.key, delegate: plex_delegate)}
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      trans = described_class.new(item)
+      expect(trans).to be_a described_class
+      expect(trans).to be_a TivoHMO::API::Transcoder
+      expect(trans.source_filename).to eq '/foo'
+    end
+
+  end
+
+end

data/spec/adapters/streamio/metadata_spec.rb

@@ -0,0 +1,34 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/streamio'
+
+describe TivoHMO::Adapters::StreamIO::Metadata do
+
+  let(:item) { TestAPI::Item.new(video_fixture(:tiny)) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      md = described_class.new(item)
+      expect(md).to be_a described_class
+      expect(md.item).to eq(item)
+      expect(md.movie).to be_instance_of FFMPEG::Movie
+      expect(md.duration).to be(7)
+    end
+
+    it "should not fail" do
+      orig_appenders = Logging.logger.root.appenders
+      Logging.logger.root.appenders = nil
+      begin
+        expect(FFMPEG::Movie).to receive(:new).and_raise("bad")
+        md = described_class.new(item)
+        expect(md).to be_a described_class
+        expect(md.movie).to be_nil
+        expect(md.duration).to eq(0)
+      ensure
+        Logging.logger.root.appenders = orig_appenders
+      end
+    end
+
+  end
+
+end

data/spec/adapters/streamio/transcoder_spec.rb

@@ -0,0 +1,42 @@
+require_relative "../../spec_helper"
+require 'tivohmo/adapters/streamio'
+
+describe TivoHMO::Adapters::StreamIO::Transcoder do
+
+  let(:item) { TestAPI::Item.new(video_fixture(:tiny)) }
+
+  describe "#initialize" do
+
+    it "should instantiate" do
+      trans = described_class.new(item)
+      expect(trans).to be_a described_class
+      expect(trans.item).to eq(item)
+    end
+
+  end
+
+  describe "#transcoder_options" do
+
+    let(:subject) { described_class.new(item) }
+
+    it "returns a hash" do
+      opts = subject.transcoder_options
+      expect(opts).to be_instance_of(Hash)
+    end
+
+  end
+
+  describe "#transcode" do
+
+    let(:subject) { described_class.new(item) }
+    let(:destination) { Tempfile.new('streamio_transcode') }
+
+    it "performs a valid transcode" do
+      thread = subject.transcode(destination)
+      movie = FFMPEG::Movie.new(destination.path)
+      expect(movie.valid?).to be(true)
+    end
+
+  end
+
+end

data/spec/api/application_spec.rb

@@ -0,0 +1,63 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Application do
+
+  def test_class
+    TestAPI::Application
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      node = test_class.new('a')
+      expect(node).to be_a(TivoHMO::API::Container)
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq('a')
+      expect(node.app).to eq(node)
+      expect(node.content_type).to eq("x-container/tivo-videos")
+      expect(node.source_format).to eq("x-container/folder")
+    end
+
+  end
+
+  describe "#metadata_for" do
+
+    before(:each) do
+      @app = test_class.new('a')
+      @item = double(TivoHMO::API::Item)
+    end
+
+    it "should return nil when no metadata_class" do
+      expect(@app.metadata_for(@item)).to eq(nil)
+    end
+
+    it "should return an instance of the metadata class when present" do
+      o = double()
+      c = double(TivoHMO::API::Metadata, :new => o)
+      @app.metadata_class = c
+      expect(@app.metadata_for(@item)).to eq(o)
+    end
+
+  end
+
+  describe "#transcoder_for" do
+
+    before(:each) do
+      @app = test_class.new('a')
+      @item = double(TivoHMO::API::Item)
+    end
+
+    it "should return nil when no transcoder_class" do
+      expect(@app.transcoder_for(@item)).to eq(nil)
+    end
+
+    it "should return an instance of the transcoder class when present" do
+      o = double()
+      c = double(TivoHMO::API::Transcoder, :new => o)
+      @app.transcoder_class = c
+      expect(@app.transcoder_for(@item)).to eq(o)
+    end
+
+  end
+
+end

data/spec/api/container_spec.rb

@@ -0,0 +1,34 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Container do
+
+  def test_class
+    TestAPI::Container
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      node = test_class.new('c')
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq('c')
+      expect(node.uuid).to_not be_nil
+      expect(node.content_type).to eq("x-tivo-container/tivo-videos")
+      expect(node.source_format).to eq("x-tivo-container/folder")
+    end
+
+  end
+
+  describe "#refresh" do
+
+    it "should clear children" do
+      node = test_class.new('c')
+      node2 = node.add_child(test_class.new('c2'))
+      expect(node.children).to eq([node2])
+      node.refresh
+      expect(node.children).to eq([])
+    end
+
+  end
+
+end

data/spec/api/item_spec.rb

@@ -0,0 +1,53 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Item do
+
+  def test_class
+    TestAPI::Item
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      node = test_class.new('i')
+      expect(node).to be_a(TivoHMO::API::Item)
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq('i')
+      expect(node.title).to eq('i')
+      expect(node.content_type).to eq("video/x-tivo-mpeg")
+      expect(node.source_format).to eq("video/x-tivo-mpeg")
+    end
+
+  end
+
+  describe "#metadata" do
+
+    before(:each) do
+      @app = double(TivoHMO::API::Application)
+      @node = test_class.new('i')
+      @node.app = @app
+    end
+
+    it "asks app for metadata" do
+      expect(@app).to receive(:metadata_for).with(@node)
+      @node.metadata
+    end
+
+  end
+
+  describe "#transcoder" do
+
+    before(:each) do
+      @app = double(TivoHMO::API::Application)
+      @node = test_class.new('i')
+      @node.app = @app
+    end
+
+    it "asks app for transcoder" do
+      expect(@app).to receive(:transcoder_for).with(@node)
+      @node.transcoder
+    end
+
+  end
+
+end

data/spec/api/metadata_spec.rb

@@ -0,0 +1,59 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Metadata do
+
+  class TestMetadata
+    include TivoHMO::API::Metadata
+  end
+
+  def test_class
+    TestMetadata
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      item = double(TivoHMO::API::Item)
+      md = test_class.new(item)
+      expect(md).to be_a(TivoHMO::API::Metadata)
+      expect(md.item).to eq(item)
+    end
+
+  end
+
+  describe "#estimate_source_size" do
+
+    it "uses transcoder to estimate size" do
+      transcoder = double(TivoHMO::API::Transcoder,
+                          transcoder_options: {video_bitrate: 1, audio_bitrate: 2})
+      item = double(TivoHMO::API::Item, transcoder: transcoder)
+
+      md = test_class.new(item)
+      md.duration = 3
+      expect(md.estimate_source_size).to eq(1147)
+    end
+
+    it "uses defaults if no bitrates in options to estimate size" do
+      transcoder = double(TivoHMO::API::Transcoder,
+                          transcoder_options: {})
+      item = double(TivoHMO::API::Item, transcoder: transcoder)
+
+      md = test_class.new(item)
+      md.duration = 3
+      expect(md.estimate_source_size).to eq(11646360)
+    end
+
+  end
+
+  describe "#source_size" do
+
+    it "uses estimate_source_size" do
+      item = double(TivoHMO::API::Item)
+      md = test_class.new(item)
+      expect(md).to receive(:estimate_source_size).and_return(5)
+      expect(md.source_size).to eq(5)
+    end
+
+  end
+
+end

data/spec/api/node_spec.rb

@@ -0,0 +1,178 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Node do
+
+  class TestNode
+    include TivoHMO::API::Node
+  end
+
+  def test_class
+    TestNode
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      node = test_class.new('n')
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq('n')
+      expect(node.title).to eq('n')
+      expect(node.children).to eq([])
+    end
+
+    it "force title to string" do
+      node = test_class.new(:n)
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq(:n)
+      expect(node.title).to eq('n')
+    end
+
+  end
+
+  describe "root?" do
+
+    it "should be false if not root" do
+      node = test_class.new('r')
+      expect(node.root?).to be(false)
+    end
+
+    it "should be true if root" do
+      node = test_class.new('r')
+      node.root = node
+      expect(node.root?).to be(true)
+    end
+
+  end
+
+  describe "app?" do
+
+    it "should be false if not app" do
+      node = test_class.new('a')
+      expect(node.app?).to be(false)
+    end
+
+    it "should be true if root" do
+      node = test_class.new('a')
+      node.app = node
+      expect(node.app?).to be(true)
+    end
+
+  end
+
+  describe "#add_child" do
+
+    before(:each) do
+      @root = test_class.new('r')
+      @root.root = @root
+    end
+
+    it "should setup parent/child relationship" do
+      child = test_class.new('c')
+      @root.add_child(child)
+      expect(@root.children).to eq([child])
+      expect(child.parent).to eq(@root)
+    end
+
+    it "should preserve root for children" do
+      app1 = test_class.new('a1')
+      app1.app = app1
+      app2 = test_class.new('a2')
+      app2.app = app2
+
+      @root.add_child(app1)
+      @root.add_child(app2)
+
+      child1 = test_class.new('c1')
+      app1.add_child(child1)
+
+      child2 = test_class.new('c2')
+      app2.add_child(child2)
+
+      expect(@root.root).to eq(@root)
+      expect(app1.root).to eq(@root)
+      expect(app2.root).to eq(@root)
+      expect(child1.root).to eq(@root)
+      expect(child2.root).to eq(@root)
+    end
+
+    it "should preserve app for children" do
+      app1 = test_class.new('a1')
+      app1.app = app1
+      app2 = test_class.new('a2')
+      app2.app = app2
+
+      @root.add_child(app1)
+      @root.add_child(app2)
+
+      child1 = test_class.new('c1')
+      app1.add_child(child1)
+
+      child2 = test_class.new('c2')
+      app2.add_child(child2)
+
+      expect(app1.app).to eq(app1)
+      expect(child1.app).to eq(app1)
+
+      expect(app2.app).to eq(app2)
+      expect(child2.app).to eq(app2)
+    end
+
+  end
+
+  describe "#title_path" do
+
+    before(:each) do
+      @root = test_class.new('r')
+      @root.root = @root
+      @child1 = @root.add_child(test_class.new('c1'))
+      @child11 = @child1.add_child(test_class.new('c11'))
+      @child111 = @child11.add_child(test_class.new('c111'))
+      @child2 = @root.add_child(test_class.new('c2'))
+    end
+
+    it "should be '/' for root" do
+      expect(@root.title_path).to eq('/')
+    end
+
+    it "should reflect the heirarchy" do
+      expect(@child111.title_path).to eq('/c1/c11/c111')
+      expect(@child2.title_path).to eq('/c2')
+    end
+
+  end
+
+  describe "#find" do
+
+    before(:each) do
+      @root = test_class.new('r')
+      @root.root = @root
+      @child1 = @root.add_child(test_class.new('c1'))
+      @child11 = @child1.add_child(test_class.new('c11'))
+      @child111 = @child11.add_child(test_class.new('c111'))
+      @child2 = @root.add_child(test_class.new('c2'))
+    end
+
+    it "should find '/' for root" do
+      expect(@root.find('/')).to eq(@root)
+      expect(@child111.find('/')).to eq(@root)
+    end
+
+    it "should find relative path" do
+      expect(@child1.find('c11')).to eq(@child11)
+    end
+
+    it "should find deep full path" do
+      expect(@root.find('/c1/c11/c111')).to eq(@child111)
+      expect(@child11.find('/c1/c11/c111')).to eq(@child111)
+    end
+
+    it "should find deep relative path" do
+      expect(@root.find('c1/c11/c111')).to eq(@child111)
+      expect(@child1.find('c11/c111')).to eq(@child111)
+      expect(@root.find('c11/c111')).to eq(nil)
+      expect(@child1.find('c1/c11/c111')).to eq(nil)
+    end
+
+  end
+
+end

data/spec/api/server_spec.rb

@@ -0,0 +1,24 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Server do
+
+  def test_class
+    TivoHMO::API::Server
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      node = test_class.new
+      expect(node).to be_a(TivoHMO::API::Container)
+      expect(node).to be_a(TivoHMO::API::Node)
+      expect(node.identifier).to eq('TivoHMO Server')
+      expect(node.title).to eq(Socket.gethostname.split(".").first)
+      expect(node.root).to eq(node)
+      expect(node.content_type).to eq("x-container/tivo-server")
+      expect(node.source_format).to eq("x-container/folder")
+    end
+
+  end
+
+end

data/spec/api/transcoder_spec.rb

@@ -0,0 +1,25 @@
+require_relative "../spec_helper"
+
+describe TivoHMO::API::Transcoder do
+
+  class TestTranscoder
+    include TivoHMO::API::Transcoder
+  end
+
+  def test_class
+    TestTranscoder
+  end
+
+  describe "#initialize" do
+
+    it "should initialize" do
+      item = double(TivoHMO::API::Item, identifier: 'foo')
+      trans = test_class.new(item)
+      expect(trans).to be_a(TivoHMO::API::Transcoder)
+      expect(trans.item).to eq(item)
+      expect(trans.source_filename).to eq('foo')
+    end
+
+  end
+
+end