tablo_connect 0.0.2

data/spec/javascript/unit/controllers/movies_controller_spec.js

@@ -0,0 +1,55 @@
+describe('MoviesCtrl', function () {
+  'use strict';
+
+  var $httpBackend,
+      scope,
+      ctrl,
+      alertsService,
+      tabloService,
+      tabloBaseUrl;
+
+  beforeEach(module('ac.tabloConnectApp'));
+
+  beforeEach(inject(function ($rootScope, $controller, _$httpBackend_, _alertsService_, _tabloService_, _tabloBaseUrl_) {
+    $httpBackend = _$httpBackend_;
+    scope = $rootScope.$new();
+    alertsService = _alertsService_;
+    tabloService = _tabloService_;
+    tabloBaseUrl = _tabloBaseUrl_;
+    spyOn(alertsService, 'getAlerts').and.callThrough();
+    spyOn(tabloService, 'movieData').and.callThrough();
+    spyOn(tabloService, 'initPollStatus').and.callThrough();
+    ctrl = $controller('MoviesCtrl', {$scope: scope, $element: scope.$element, tabloBaseUrl: tabloBaseUrl});
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  it("calls alertsService.getAlerts()", function () {
+    expect(alertsService.getAlerts).toHaveBeenCalled();
+  });
+
+  it("calls tabloService.movieData", function () {
+    expect(tabloService.movieData).toHaveBeenCalled();
+  });
+
+  it('sets the tabloBaseUrl', function () {
+    expect(scope.tabloBaseUrl).toEqual(tabloBaseUrl);
+  });
+
+  describe('$scope.copyRecording', function () {
+    it('calls tabloService.initCopy', function () {
+      spyOn(tabloService, 'initCopy');
+      spyOn(alertsService, 'clearAlerts');
+      scope.copyRecording({tablo_id: 1234});
+      expect(tabloService.initCopy).toHaveBeenCalledWith({tablo_id: 1234}, 'movie');
+      expect(alertsService.clearAlerts).toHaveBeenCalled();
+    });
+  });
+
+  it("calls tabloService.initPollStatus", function () {
+    expect(tabloService.initPollStatus).toHaveBeenCalledWith([], 'movie');
+  });
+});

data/spec/javascript/unit/controllers/shows_controller_spec.js

@@ -0,0 +1,33 @@
+describe('ShowsCtrl', function () {
+  'use strict';
+
+  var $httpBackend,
+      scope,
+      ctrl,
+      tabloService,
+      tabloBaseUrl;
+
+  beforeEach(module('ac.tabloConnectApp'));
+
+  beforeEach(inject(function ($rootScope, $controller, _$httpBackend_, _tabloService_, _tabloBaseUrl_) {
+    $httpBackend = _$httpBackend_;
+    scope = $rootScope.$new();
+    tabloService = _tabloService_;
+    tabloBaseUrl = _tabloBaseUrl_;
+    spyOn(tabloService, 'showData').and.callThrough();
+    ctrl = $controller('ShowsCtrl', {$scope: scope, $element: scope.$element, tabloBaseUrl: tabloBaseUrl});
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  it ("calls tabloService.showData", function(){
+    expect(tabloService.showData).toHaveBeenCalled();
+  });
+
+  it('sets the tabloBaseUrl', function () {
+    expect(scope.tabloBaseUrl).toEqual(tabloBaseUrl);
+  });
+});

data/spec/javascript/unit/filters/titleize_filter_spec.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/* jasmine specs for filters go here */
+
+describe('filters', function () {
+  beforeEach(module('ac.titleize'));
+
+  describe('titleize', function () {
+    it('returns a formatted string with spaces as a title', inject(function (titleizeFilter) {
+      expect(titleizeFilter('the quick red fox')).toBe('The Quick Red Fox');
+    }));
+
+    it('returns a formatted string with underscores as a title', inject(function (titleizeFilter) {
+      expect(titleizeFilter('jumped_over_the_lazy_brown_dog')).toBe('Jumped Over The Lazy Brown Dog');
+    }));
+
+    it('returns a formatted string with underscores and spaces as a title', inject(function (titleizeFilter) {
+      expect(titleizeFilter('lorem_ipsum dolor sit_amEt, conSectetur adipisicing elit')).toBe('Lorem Ipsum Dolor Sit Amet, Consectetur Adipisicing Elit');
+    }));
+
+    it('returns the value if it is not truthy', inject(function (titleizeFilter) {
+      expect(titleizeFilter(undefined)).toBe(undefined);
+    }));
+  });
+});

data/spec/javascript/unit/filters/url_filter_spec.js

@@ -0,0 +1,33 @@
+describe('filters', function () {
+  'use strict';
+
+  beforeEach(module('ac.url'));
+
+  describe('urlencode', function () {
+    describe('when the value is undefined', function () {
+      it('returns undefined', inject(function (urlencodeFilter) {
+        expect(urlencodeFilter(undefined)).toBe(undefined);
+      }));
+    });
+
+    describe('when the value is defined', function () {
+      it('returns the string url encoded', inject(function (urlencodeFilter) {
+        expect(urlencodeFilter('20/20')).toBe('20%2F20');
+      }));
+    });
+  });
+
+  describe('urldecode', function () {
+    describe('when the value is undefined', function () {
+      it('returns undefined', inject(function (urldecodeFilter) {
+        expect(urldecodeFilter(undefined)).toBe(undefined);
+      }));
+    });
+
+    describe('when the value is defined', function () {
+      it('returns the string url decoded', inject(function (urldecodeFilter) {
+        expect(urldecodeFilter('20%2F20')).toBe('20/20');
+      }));
+    });
+  });
+});

data/spec/javascript/unit/modules/alerts/directives/alerts_directive_spec.js

@@ -0,0 +1,39 @@
+describe('acAlerts directive', function() {
+  'use strict';
+
+  var $compile,
+      scope,
+      element;
+
+  beforeEach(module('ngSanitize',
+      'ac.alerts',
+      '/assets/tablo_connect/ng_app/modules/alerts/templates/alerts.html'
+  ));
+
+  beforeEach(inject(function(_$compile_, $rootScope){
+    $compile = _$compile_;
+    scope = $rootScope.$new();
+  }));
+
+  it('replaces the element with the alerts html', function() {
+    element = $compile('<ac-alerts></ac-alerts>')(scope);
+    scope.$digest();
+    expect(element.attr('id')).toEqual('alerts');
+  });
+
+  describe('$scope.closeAlert()', function () {
+    it('splices the alert from the alerts array', function() {
+      scope.alerts = {messages: [
+        {type: 'danger', msg: 'There was an error.'},
+        {type: 'success', msg: 'Success!'}
+      ]};
+      element = $compile('<ac-alerts></ac-alerts>')(scope);
+      scope.$digest();
+      expect(element.find('.alert').length).toEqual(2);
+      scope.closeAlert(0);
+      scope.$digest();
+      expect(element.find('.alert').length).toEqual(1);
+      expect(element.find('.alert').text()).toContain('Success!');
+    });
+  });
+});

data/spec/javascript/unit/modules/alerts/services/alerts_service_spec.js

@@ -0,0 +1,51 @@
+describe('alertsService', function () {
+  'use strict';
+
+  var $httpBackend,
+      alertsService;
+
+  beforeEach(module('ngSanitize',
+      'ac.alertsService',
+      '/assets/tablo_connect/ng_app/modules/alerts/templates/alerts.html'
+  ));
+
+  beforeEach(inject(function (_$httpBackend_, _alertsService_) {
+    $httpBackend = _$httpBackend_;
+    alertsService = _alertsService_;
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  describe('getAlerts()', function () {
+    it('returns the alerts', function () {
+      expect(alertsService.getAlerts()).toEqual({messages: []});
+    });
+  });
+
+  describe('addAlert()', function () {
+    it('adds the alert to the alerts.messages array', function () {
+      expect(alertsService.getAlerts()).toEqual({messages: []});
+      alertsService.addAlert('success', 'In my experience there is no such thing as luck.');
+      expect(alertsService.getAlerts()).toEqual({
+        messages: [{
+          type: 'success',
+          msg: 'In my experience there is no such thing as luck.'
+        }]
+      });
+    });
+  });
+
+  describe('getAlerts()', function () {
+    it('returns the alerts', function () {
+      alertsService.addAlert('success', 'In my experience there is no such thing as luck.');
+      alertsService.addAlert('danger', 'I find your lack of faith disturbing.');
+      expect(alertsService.getAlerts().messages.length).toEqual(2);
+      alertsService.clearAlerts();
+      expect(alertsService.getAlerts().messages.length).toEqual(0);
+    });
+  });
+
+});

data/spec/javascript/unit/modules/tablo_sync/directives/tablo_sync_directive_spec.js

@@ -0,0 +1,68 @@
+describe('tabloSync directive', function () {
+  'use strict';
+
+  var $compile,
+      $httpBackend,
+      scope,
+      element,
+      tabloSyncService,
+      alertsService;
+
+  beforeEach(module('ngSanitize',
+      'ac.tabloSyncModule',
+      'ac.alertsModule',
+      '/assets/tablo_connect/ng_app/modules/tablo_sync/templates/tablo_sync.html'
+  ));
+
+  beforeEach(inject(function (_$compile_, _$httpBackend_, $rootScope, _tabloSyncService_, _alertsService_) {
+    $compile = _$compile_;
+    $httpBackend = _$httpBackend_;
+    tabloSyncService = _tabloSyncService_;
+    alertsService = _alertsService_;
+    scope = $rootScope.$new();
+    element = $compile('<tablo-sync></tablo-sync>')(scope);
+    scope.$digest();
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  it('replaces the element with the tablo sync html', function () {
+    expect(element.find('a').length).toBe(1);
+  });
+
+  it('sets $scope.syncing to false', function () {
+    expect(scope.syncing).toBe(false);
+  });
+
+  describe('syncRecordings()', function () {
+    beforeEach(function () {
+      spyOn(alertsService, 'clearAlerts').and.callThrough();
+      spyOn(tabloSyncService, 'syncRecordings').and.callThrough();
+      $httpBackend.when('GET', '/tablo/sync').respond(200);
+    });
+
+    it('calls alertsService.clearAlerts()', function () {
+      scope.syncRecordings();
+      expect(alertsService.clearAlerts).toHaveBeenCalled();
+      $httpBackend.flush();
+    });
+
+    it('sets $scope.syncing to true', function () {
+      scope.syncRecordings();
+      scope.$digest();
+      expect(scope.syncing).toBe(true);
+      expect(element.find('a').length).toBe(0);
+      expect(element.find('p:eq(0)').text()).toContain('Sync in progress.');
+      $httpBackend.flush();
+    });
+
+    it('calls tabloSyncService.syncRecordingings()', function () {
+      scope.syncRecordings();
+      expect(tabloSyncService.syncRecordings).toHaveBeenCalled();
+      $httpBackend.flush();
+    });
+  });
+});

data/spec/javascript/unit/modules/tablo_sync/services/tablo_sync_service_spec.js

@@ -0,0 +1,26 @@
+describe('tabloSyncService', function () {
+  'use strict';
+
+  var $httpBackend,
+      tabloSyncService;
+
+  beforeEach(module('ngSanitize',
+      'ac.tabloSyncService'
+  ));
+
+  beforeEach(inject(function (_$httpBackend_, _tabloSyncService_) {
+    $httpBackend = _$httpBackend_;
+    tabloSyncService = _tabloSyncService_;
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  describe('syncData()', function () {
+    it('returns the syncData', function () {
+      expect(tabloSyncService.syncData()).toEqual({});
+    });
+  });
+});

data/spec/javascript/unit/services/tablo_service_spec.js

@@ -0,0 +1,28 @@
+describe('tabloService', function () {
+  'use strict';
+
+  var $httpBackend,
+      tabloService;
+
+  beforeEach(module('ac.tabloConnectApp', 'ac.tabloService'));
+
+  beforeEach(inject(function (_$httpBackend_, _tabloService_) {
+    $httpBackend = _$httpBackend_;
+    tabloService = _tabloService_;
+  }));
+
+  afterEach(function () {
+    $httpBackend.verifyNoOutstandingExpectation();
+    $httpBackend.verifyNoOutstandingRequest();
+  });
+
+  describe('initCopy', function () {
+    it('sets the recording.copy_status to in_progress', function () {
+      $httpBackend.expectGET('/tablo/copy/1234/movie').respond({copy_status: 'in_progress'});
+      var recording = {tablo_id: 1234};
+      tabloService.initCopy(recording, 'movie');
+      $httpBackend.flush();
+      expect(recording.copy_status).toEqual('in_progress');
+    });
+  });
+});

data/spec/models/tablo_connect/movie_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module TabloConnect
+  describe Movie do
+    describe "validates presence of tablod_id" do
+      it { is_expected.to validate_presence_of(:tablo_id) }
+    end
+
+    describe "validates uniqueness of tablod_id" do
+      it { is_expected.to validate_uniqueness_of(:tablo_id) }
+    end
+
+    describe ".all_order_title" do
+      let!(:movie1) { FactoryGirl.create(:tablo_connect_movie, title: 'B starts the title') }
+      let!(:movie2) { FactoryGirl.create(:tablo_connect_movie, title: 'A starts the title') }
+
+      it "orders the movies by title" do
+        movies =TabloConnect::Movie.all_order_title
+        expect(movies[0].title).to eq movie2.title
+        expect(movies[1].title).to eq movie1.title
+      end
+    end
+
+    describe ".delete_by_tablo_id" do
+      let!(:movie1) { FactoryGirl.create(:tablo_connect_movie, title: 'B starts the title') }
+
+      it "deletes all for tablo_id provided" do
+        expect{TabloConnect::Movie.delete_by_tablo_id movie1.tablo_id}.to change{TabloConnect::Movie.count}.by -1
+      end
+    end
+  end
+end

data/spec/models/tablo_connect/show_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module TabloConnect
+  describe Show do
+    describe "validates presence of tablod_id" do
+      it { is_expected.to validate_presence_of(:tablo_id) }
+    end
+
+    describe "validates uniqueness of tablod_id" do
+      it { is_expected.to validate_uniqueness_of(:tablo_id) }
+    end
+
+    describe ".shows" do
+      let!(:show) { FactoryGirl.create(:tablo_connect_show) }
+
+      it "returns the show name" do
+        expect(TabloConnect::Show.shows.first[0]).to eq show.show
+      end
+
+      it "returns the show count" do
+        expect(TabloConnect::Show.shows.first[1]).to be 1
+      end
+    end
+
+    describe ".show_episodes" do
+      let!(:show1) { FactoryGirl.create(:tablo_connect_show, show: "Alf") }
+      let!(:show2) { FactoryGirl.create(:tablo_connect_show, show: "Alf") }
+      let!(:show3) { FactoryGirl.create(:tablo_connect_show) }
+
+      it "returns all shows matching the show parameter" do
+        expect(TabloConnect::Show.show_episodes(show1.show).count).to be 2
+      end
+    end
+
+    describe ".shows_with_image_id" do
+      let!(:show1) { FactoryGirl.create(:tablo_connect_show, show: "Charles in Charge") }
+      let!(:show2) { FactoryGirl.create(:tablo_connect_show, show: "Mr. Belvedere") }
+      let!(:show3) { FactoryGirl.create(:tablo_connect_show, show: "Robotech") }
+
+      it "returns an array of shows" do
+        expect(TabloConnect::Show.shows_with_image_id.count).to be 3
+      end
+
+      it "returns an array of objects with the show name" do
+        expect(TabloConnect::Show.shows_with_image_id.first[:show]).to eq 'Charles in Charge'
+      end
+
+      it "returns an array of objects with the show count" do
+        expect(TabloConnect::Show.shows_with_image_id.first[:count]).to be 1
+      end
+
+      it "returns an array of objects with the image_id" do
+        expect(TabloConnect::Show.shows_with_image_id.first[:image_id]).to eq show1.image_id
+      end
+    end
+
+    describe ".delete_by_tablo_id" do
+      let!(:show_to_delete) { FactoryGirl.create(:tablo_connect_show) }
+
+      it "deletes all for tablo_id provided" do
+        expect{TabloConnect::Show.delete_by_tablo_id show_to_delete.tablo_id}.to change{TabloConnect::Show.count}.by -1
+      end
+    end
+  end
+end