lws 8.1.0 → 8.1.1

data/test/digital_signage_test.rb

@@ -1,980 +0,0 @@
-#
-# Copyright © 2016–2021 LeftClick Web Services B.V.
-#
-# This software is property of LeftClick Web Services B.V. and cannot be
-# redistributed and/or modified without permission.  The software or any
-# of its parts cannot be used for any other purposes than the LeftClick
-# services and only during a valid license subscription.  For more
-# information, please contact LeftClick Web Services B.V. at:
-# Schootense Dreef 20A, 5708 HZ Helmond, The Netherlands,
-# info@leftclick.eu, +3185-4444-004.
-
-
-require "test_helper"
-
-class TestDigitalSignageChannel < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel = Channel.find(2)
-  end
-
-  def test_valid
-    refute_nil(@channel)
-    assert_instance_of(Channel, @channel)
-    refute_nil(@channel.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(LWS::Auth::Company, @channel.company)
-    assert_instance_of(Display, @channel.display)
-    assert_instance_of(Channel::Group, @channel.groups.first)
-    assert_instance_of(Player, @channel.players.first)
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Slide, @channel.slides.first)
-    assert_instance_of(Channel::Tag, @channel.tags.first)
-    assert_instance_of(Channel::TimeSchedule, @channel.time_schedule)
-    assert_instance_of(Channel::TimeScheduleOverride, @channel.time_schedule_overrides.first)
-  end
-
-end
-
-class TestDigitalSignageChannelGroup < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel_group = Channel::Group.find(2)
-  end
-
-  def test_valid
-    refute_nil(@channel_group)
-    assert_instance_of(Channel::Group, @channel_group)
-    refute_nil(@channel_group.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel, @channel_group.channels.first)
-    assert_instance_of(LWS::Auth::Company, @channel_group.company)
-    assert_instance_of(Channel::Group, @channel_group.parent)
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Slide, @channel_group.slides.first)
-    assert_instance_of(Channel::Group::Tag, @channel_group.tags.first)
-    assert_instance_of(Channel::TimeScheduleOverride, @channel_group.time_schedule_overrides.first)
-  end
-
-end
-
-class TestDigitalSignageChannelGroupTag < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel_group = Channel::Group.all.first
-    # Channel group tags only exist as child objects of a channel group
-    @channel_group_tag = @channel_group.tags.first
-  end
-
-  def test_valid
-    refute_nil(@channel_group_tag)
-    assert_instance_of(Channel::Group::Tag, @channel_group_tag)
-    refute_nil(@channel_group_tag.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel::Group, @channel_group_tag.group)
-    assert_equal(@channel_group, @channel_group_tag.group)
-  end
-
-end
-
-class TestDigitalSignageChannelTag < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel = Channel.find(2)
-    # Channel tags only exist as child objects of a channel
-    @channel_tag = @channel.tags.first
-  end
-
-  def test_valid
-    refute_nil(@channel_tag)
-    assert_instance_of(Channel::Tag, @channel_tag)
-    refute_nil(@channel_tag.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel, @channel_tag.channel)
-    assert_equal(@channel, @channel_tag.channel)
-  end
-
-end
-
-class TestDigitalSignageChannelTimeSchedule < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel_time_schedule = Channel::TimeSchedule.find(1)
-  end
-
-  def test_valid
-    refute_nil(@channel_time_schedule)
-    assert_instance_of(Channel::TimeSchedule, @channel_time_schedule)
-    refute_nil(@channel_time_schedule.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel, @channel_time_schedule.channels.first)
-    assert_instance_of(LWS::Auth::Company, @channel_time_schedule.company)
-  end
-
-end
-
-class TestDigitalSignageChannelTimeScheduleDay < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel_time_schedule = Channel::TimeSchedule.find(1)
-    # Time schedule days only exist as child objects of a time schedule
-    @channel_time_schedule_day = @channel_time_schedule.days.first
-  end
-
-  def test_valid
-    refute_nil(@channel_time_schedule_day)
-    assert_instance_of(Channel::TimeSchedule::Day, @channel_time_schedule_day)
-    refute_nil(@channel_time_schedule_day.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel::TimeSchedule,
-                       @channel_time_schedule_day.time_schedule)
-    assert_equal(@channel_time_schedule, @channel_time_schedule_day.time_schedule)
-  end
-
-end
-
-class TestDigitalSignageChannelTimeScheduleOverride < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @channel_time_schedule_override = Channel::TimeScheduleOverride.find(1)
-  end
-
-  def test_valid
-    refute_nil(@channel_time_schedule_override)
-    assert_instance_of(Channel::TimeScheduleOverride, @channel_time_schedule_override)
-    refute_nil(@channel_time_schedule_override.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel::Group, @channel_time_schedule_override.groups.first)
-    assert_instance_of(Channel, @channel_time_schedule_override.channels.first)
-    assert_instance_of(LWS::Auth::Company, @channel_time_schedule_override.company)
-  end
-
-end
-
-class TestDigitalSignageDisplay < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @display = Display.find(1)
-  end
-
-  def test_valid
-    refute_nil(@display)
-    assert_instance_of(Display, @display)
-    refute_nil(@display.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel, @display.channels.first)
-    assert_instance_of(Display::Input, @display.inputs.first)
-    assert_instance_of(Display::Resolution, @display.resolutions.first)
-  end
-
-end
-
-class TestDigitalSignageDisplayInput < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @display = Display.find(1)
-    # Display inputs only exist as child objects of a display
-    @display_input = @display.inputs.first
-  end
-
-  def test_valid
-    refute_nil(@display_input)
-    assert_instance_of(Display::Input, @display_input)
-    refute_nil(@display_input.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Display, @display_input.display)
-    assert_equal(@display, @display_input.display)
-  end
-
-end
-
-class TestDigitalSignageDisplayResolution < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @display_resolution = Display::Resolution.all.first
-  end
-
-  def test_valid
-    refute_nil(@display_resolution)
-    assert_instance_of(Display::Resolution, @display_resolution)
-    refute_nil(@display_resolution.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Display, @display_resolution.displays.first)
-    assert_instance_of(Player::Model, @display_resolution.models.first)
-  end
-
-end
-
-class TestDigitalSignageLayout < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout = Layout.find(1)
-  end
-
-  def test_valid
-    refute_nil(@layout)
-    assert_instance_of(Layout, @layout)
-    refute_nil(@layout.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout::Category, @layout.categories.first)
-    assert_instance_of(LWS::Auth::Company, @layout.company_owner)
-    # FIXME: Missing parent_id field in LWS
-    #assert_instance_of(Layout, @layout.parent)
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Slide, @layout.slides.first)
-    assert_instance_of(Layout::Version, @layout.versions.find(1))
-  end
-
-end
-
-class TestDigitalSignageLayoutCategory < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout_category = Layout::Category.find(1)
-  end
-
-  def test_valid
-    refute_nil(@layout_category)
-    assert_instance_of(Layout::Category, @layout_category)
-    refute_nil(@layout_category.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout, @layout_categories.layouts.first)
-  end
-
-end
-
-class TestDigitalSignageLayoutElement < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout = Layout.find(1)
-    # Layout versions only exist as child objects of layouts
-    @layout_version = @layout.versions.find(1)
-    # Layout elements only exist as child objects of layout versions
-    @layout_element = @layout_version.elements.first
-  end
-
-  def test_valid
-    refute_nil(@layout_element)
-    assert_instance_of(Layout::Element, @layout_element)
-    refute_nil(@layout_element.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Layout::Element::Customizable, @layout_element.customizables.first)
-    assert_instance_of(Layout::Element::Property, @layout_element.properties.first)
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout::Version, @layout_element.version)
-    #assert_equal(@layout_version, @layout_element.version)
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout::Element, @layout_element.parent)
-  end
-
-end
-
-class TestDigitalSignageLayoutElementCustomizable < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout = Layout.find(1)
-    # Layout versions only exist as child objects of layouts
-    @layout_version = @layout.versions.find(1)
-    # Layout elements only exist as child objects of layout versions
-    @layout_element = @layout_version.elements.first
-    # Layout element customizables only exist as child objects of layout elements
-    @layout_element_customizable = @layout_element.customizables.first
-  end
-
-  def test_valid
-    refute_nil(@layout_element_customizable)
-    assert_instance_of(Layout::Element::Customizable, @layout_element_customizable)
-    refute_nil(@layout_element_customizable.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout::Element, @layout_element_customizable.element)
-    #assert_equal(@layout_element, @layout_element_customizable.element)
-  end
-
-end
-
-class TestDigitalSignageLayoutElementProperty < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout = Layout.find(1)
-    # Layout versions only exist as child objects of layouts
-    @layout_version = @layout.versions.find(1)
-    # Layout elements only exist as child objects of layout versions
-    @layout_element = @layout_version.elements.first
-    # Layout element properties only exist as child objects of layout elements
-    @layout_element_property = @layout_element.properties.first
-  end
-
-  def test_valid
-    refute_nil(@layout_element_property)
-    assert_instance_of(Layout::Element::Property, @layout_element_property)
-    refute_nil(@layout_element_property.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing endpoint in LWS
-    #assert_instance_of(Layout::Element, @layout_element_property.element)
-    #assert_equal(@layout_element, @layout_element_property.element)
-  end
-
-end
-
-class TestDigitalSignageLayoutVersion < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @layout = Layout.find(1)
-    # Layout versions only exist as child objects of layouts
-    @layout_version = @layout.versions.find(1)
-  end
-
-  def test_valid
-    refute_nil(@layout_version)
-    assert_instance_of(Layout::Version, @layout_version)
-    refute_nil(@layout_version.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Layout::Element, @layout_version.elements.first)
-    assert_instance_of(Layout, @layout_version.layout)
-    assert_equal(@layout, @layout_version.layout)
-  end
-
-end
-
-class TestDigitalSignagePlayer < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-  end
-
-  def test_valid
-    refute_nil(@player)
-    assert_instance_of(Player, @player)
-    refute_nil(@player.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Channel, @player.channel)
-    assert_instance_of(LWS::Auth::Company, @player.company)
-    assert_instance_of(Player::Component, @player.components.first)
-    assert_instance_of(Player::Configuration, @player.configuration)
-    assert_instance_of(Player::Log, @player.logs.first)
-    assert_instance_of(Player::Model, @player.model)
-    assert_instance_of(Player::Notification, @player.notifications.first)
-    assert_instance_of(Player::Component::Part, @player.parts.first)
-    assert_instance_of(Player::Os::ReleaseChannel, @player.release_channel)
-    assert_instance_of(Player::Request, @player.requests.first)
-    assert_instance_of(Player::Screenshot, @player.screenshots.first)
-    assert_instance_of(Player::Tag, @player.tags.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerComponent < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_component = Player::Component.all.first
-  end
-
-  def test_valid
-    refute_nil(@player_component)
-    assert_instance_of(Player::Component, @player_component)
-    refute_nil(@player_component.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Model, @player_component.models.first)
-    assert_instance_of(Player::Component::Part, @player_component.parts.first)
-    @player_component.company_id = @player_component.supplier_id
-    assert_instance_of(LWS::Auth::Company, @player_component.supplier)
-  end
-
-end
-
-class TestDigitalSignagePlayerComponentPart < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_component = Player::Component.all.first
-    # Player component parts only exist as child objects of player components
-    @player_component_part = @player_component.parts.first
-  end
-
-  def test_valid
-    refute_nil(@player_component_part)
-    assert_instance_of(Player::Component::Part, @player_component_part)
-    refute_nil(@player_component_part.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_component_part.player)
-    assert_instance_of(Player::Component, @player_component_part.component)
-    assert_equal(@player_component, @player_component_part.component)
-  end
-
-end
-
-class TestDigitalSignagePlayerConfiguration < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_configuration = Player::Configuration.all.first
-  end
-
-  def test_valid
-    refute_nil(@player_configuration)
-    assert_instance_of(Player::Configuration, @player_configuration)
-    refute_nil(@player_configuration.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(LWS::Auth::Company, @player_configuration.company)
-    assert_instance_of(Player, @player_configuration.players.first)
-    assert_instance_of(Player::PredefinedConfiguration,
-                       @player_configuration.predefined_configuration)
-
-    assert_instance_of(Player::Configuration::Setting,
-                       @player_configuration.settings.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerConfigurationSetting < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_configuration = Player::Configuration.all.first
-    # Player configuration settings only exist as child objects of player
-    # configurations
-    @player_configuration_setting = @player_configuration.settings.first
-  end
-
-  def test_valid
-    refute_nil(@player_configuration_setting)
-    assert_instance_of(Player::Configuration::Setting,
-                       @player_configuration_setting)
-    refute_nil(@player_configuration_setting.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Configuration,
-                       @player_configuration_setting.configuration)
-  end
-
-end
-
-class TestDigitalSignagePlayerLog < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-    # Player logs only exist as child object of players
-    @player_log = @player.logs.first
-  end
-
-  def test_valid
-    refute_nil(@player_log)
-    assert_instance_of(Player::Log, @player_log)
-    refute_nil(@player_log.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_log.player)
-    assert_equal(@player, @player_log.player)
-  end
-
-end
-
-class TestDigitalSignagePlayerModel < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_model = Player::Model.all.first
-  end
-
-  def test_valid
-    refute_nil(@player_model)
-    assert_instance_of(Player::Model, @player_model)
-    refute_nil(@player_model.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Os::Branch, @player_model.branches.first)
-    assert_instance_of(Player::Model::Capability,
-                       @player_model.capabilities.first)
-    assert_instance_of(Player, @player_model.players.first)
-    assert_instance_of(Player::Os::ReleaseChannel,
-                       @player_model.release_channels.first)
-    assert_instance_of(Display::Resolution, @player_model.resolutions.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerModelCapability < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_model = Player::Model.all.first
-    # Player model capabilities only exist as child objects of player models
-    @player_model_capability = @player_model.capabilities.first
-  end
-
-  def test_valid
-    refute_nil(@player_model_capability)
-    assert_instance_of(Player::Model::Capability, @player_model_capability)
-    refute_nil(@player_model_capability.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Model, @player_model_capability.model)
-    assert_equal(@player_model, @player_model_capability.model)
-  end
-
-end
-
-class TestDigitalSignagePlayerNotification < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-    # Player notifications only exist as child objects of players
-    @player_notification = @player.notifications.first
-  end
-
-  def test_valid
-    refute_nil(@player_notification)
-    assert_instance_of(Player::Notification, @player_notification)
-    refute_nil(@player_notification.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_notification.player)
-    assert_equal(@player, @player_notification.player)
-  end
-
-end
-
-class TestDigitalSignagePlayerOsBranch < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_branch = Player::Os::Branch.where(slug: "lc5102-development").first
-  end
-
-  def test_valid
-    refute_nil(@player_os_branch)
-    assert_instance_of(Player::Os::Branch, @player_os_branch)
-    refute_nil(@player_os_branch.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Os::ReleaseChannel,
-                       @player_os_branch.release_channel)
-    assert_instance_of(Player::Os::Branch::Release,
-                       @player_os_branch.releases.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerOsBranchRelease < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_branch = Player::Os::Branch.where(slug: "lc5102-development").first
-    # Player OS branch releases only exist as child objects of player OS
-    # branches
-    @player_os_branch_release = @player_os_branch.releases.last
-  end
-
-  def test_valid
-    refute_nil(@player_os_branch_release)
-    assert_instance_of(Player::Os::Branch::Release, @player_os_branch_release)
-    refute_nil(@player_os_branch_release.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Os::Branch, @player_os_branch_release.branch)
-    assert_equal(@player_os_branch, @player_os_branch_release.branch)
-    # FIXME: Bug in Spyke (#90)
-    #assert_instance_of(Player::Os::Branch::Release, @player_os_branch_release.parent)
-    # FIXME: Not available as data yet
-    #assert_instance_of(Player::Os::Branch::Release, @player_os_branch_release.promoted_release)
-    #assert_instance_of(Player::Os::Branch::Release, @player_os_branch_release.promoting_releases.first)
-    # FIXME: Chained associations don't work yet in Spyke (#89)
-    #assert_instance_of(Player::Os::Package::VersionChange,
-    #                   @player_os_branch_release.package_version_changes.first)
-    #assert_instance_of(Player::Os::Package::Version,
-    #                   @player_os_branch_release.package_versions.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerOsPackage < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_package = Player::Os::Package.all.first
-  end
-
-  def test_valid
-    refute_nil(@player_os_package)
-    assert_instance_of(Player::Os::Package, @player_os_package)
-    refute_nil(@player_os_package.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Os::Package::VersionChange,
-                       @player_os_package.version_changes.first)
-    assert_instance_of(Player::Os::Package::Version,
-                       @player_os_package.versions.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerOsPackageVersion < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_package = Player::Os::Package.all.first
-    # Player OS package versions only exist as child object of player OS
-    # packages
-    @player_os_package_version = @player_os_package.versions.first
-  end
-
-  def test_valid
-    refute_nil(@player_os_package_version)
-    assert_instance_of(Player::Os::Package::Version, @player_os_package_version)
-    refute_nil(@player_os_package_version.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing branch_id in LWS
-    #assert_instance_of(Player::Os::Branch::Release,
-    #                   @player_os_package_version.branch_releases.first)
-    assert_instance_of(Player::Os::Package,
-                       @player_os_package_version.package)
-    assert_equal(@player_os_package, @player_os_package_version.package)
-  end
-
-end
-
-class TestDigitalSignagePlayerOsPackageVersionChange < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_package = Player::Os::Package.all.first
-    # Player OS package version changes only exist as child object of
-    # player OS packages
-    @player_os_package_version_change =
-      @player_os_package.version_changes.first
-  end
-
-  def test_valid
-    refute_nil(@player_os_package_version_change)
-    assert_instance_of(Player::Os::Package::VersionChange,
-                       @player_os_package_version_change)
-    refute_nil(@player_os_package_version_change.id)
-  end
-
-  def test_valid_associations
-    # FIXME: Missing branch_id in LWS
-    #assert_instance_of(Player::Os::Branch::Release,
-    #                   @player_os_package_version_change.branch_release)
-    # FIXME: This requires that version objects have been generated
-    if @player_os_package_version_change.from_version_id.present?
-      assert_instance_of(Player::Os::Package::Version,
-                         @player_os_package_version_change.from_version)
-    end
-    assert_instance_of(Player::Os::Package,
-                       @player_os_package_version_change.package)
-    assert_equal(@player_os_package, @player_os_package_version_change.package)
-    # FIXME: This requires that version objects have been generated
-    if @player_os_package_version_change.to_version_id.present?
-      assert_instance_of(Player::Os::Package::Version,
-                         @player_os_package_version_change.to_version)
-    end
-  end
-
-end
-
-class TestDigitalSignagePlayerOsReleaseChannel < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_os_release_channel =
-      Player::Os::ReleaseChannel.where(slug: "development").first
-  end
-
-  def test_valid
-    refute_nil(@player_os_release_channel)
-    assert_instance_of(Player::Os::ReleaseChannel, @player_os_release_channel)
-    refute_nil(@player_os_release_channel.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::Os::Branch,
-                       @player_os_release_channel.branches.first)
-    assert_instance_of(Player,
-                       @player_os_release_channel.players.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerPredefinedConfiguration < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_predefined_configuration =
-      Player::PredefinedConfiguration.all.first
-  end
-
-  def test_valid
-    refute_nil(@player_predefined_configuration)
-    assert_instance_of(Player::PredefinedConfiguration,
-                       @player_predefined_configuration)
-    refute_nil(@player_predefined_configuration.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(LWS::Auth::Company,
-                       @player_predefined_configuration.company)
-    assert_instance_of(Player::Configuration,
-                       @player_predefined_configuration.configurations.first)
-    assert_instance_of(Player::PredefinedConfiguration::Setting,
-                       @player_predefined_configuration.settings.first)
-  end
-
-end
-
-class TestDigitalSignagePlayerPredefinedConfigurationSetting < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player_predefined_configuration =
-      Player::PredefinedConfiguration.all.first
-    # Predefined player configuration settings only exist as child objects
-    # of predefined player configurations
-    @player_predefined_configuration_setting =
-      @player_predefined_configuration.settings.first
-  end
-
-  def test_valid
-    refute_nil(@player_predefined_configuration_setting)
-    assert_instance_of(Player::PredefinedConfiguration::Setting,
-                       @player_predefined_configuration_setting)
-    refute_nil(@player_predefined_configuration_setting.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player::PredefinedConfiguration,
-                       @player_predefined_configuration_setting.predefined_configuration)
-  end
-
-end
-
-class TestDigitalSignagePlayerRequest < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-    # Player requests only exist as child objects of players
-    @player_request = @player.requests.first
-  end
-
-  def test_valid
-    refute_nil(@player_request)
-    assert_instance_of(Player::Request, @player_request)
-    refute_nil(@player_request.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_request.player)
-    assert_equal(@player, @player_request.player)
-    # FIXME: Chained associations don't work yet in Spyke (#89)
-    #if @player_request.processed
-    #  if @player_request.log.present?
-    #    assert_instance_of(Player::Log, @player_request.log)
-    #  elsif @player_request.screenshot.present?
-    #    assert_instance_of(Player::Screenshot, @player_request.screenshot)
-    #  else
-    #    fail "request should be associated either with feedback, a log or a screenshot"
-    #  end
-    #end
-  end
-
-end
-
-class TestDigitalSignagePlayerScreenshot < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-    # Player screenshots only exist as child objects of players
-    @player_screenshot = @player.screenshots.first
-  end
-
-  def test_valid
-    refute_nil(@player_screenshot)
-    assert_instance_of(Player::Screenshot, @player_screenshot)
-    refute_nil(@player_screenshot.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_screenshot.player)
-    assert_equal(@player, @player_screenshot.player)
-  end
-
-end
-
-class TestDigitalSignagePlayerTag < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @player = Player.find(1)
-    # Player tags only exist as child objects of players
-    @player_tag = @player.tags.first
-  end
-
-  def test_valid
-    refute_nil(@player_tag)
-    assert_instance_of(Player::Tag, @player_tag)
-    refute_nil(@player_tag.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(Player, @player_tag.player)
-    assert_equal(@player, @player_tag.player)
-  end
-
-end
-
-class TestDigitalSignageSlide < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @slide = Slide.find(1)
-  end
-
-  def test_valid
-    refute_nil(@slide)
-    assert_instance_of(Slide, @slide)
-    refute_nil(@slide.id)
-  end
-
-  def test_valid_associations
-    assert_instance_of(LWS::Auth::Account, @slide.account)
-    assert_instance_of(Channel, @slide.channels.first)
-    assert_instance_of(Channel::Group, @slide.channel_groups.first)
-    assert_instance_of(LWS::Auth::Company, @slide.company)
-    assert_instance_of(Layout, @slide.layout)
-    assert_instance_of(Slide::Schedule, @slide.schedules.first)
-  end
-
-end
-
-class TestDigitalSignageSlideSchedule < MiniTest::Test
-
-  include LWS::DigitalSignage
-
-  def setup
-    @slide = Slide.find(1)
-    # Slide schedules only exist as decendant objects of players
-    @slide_schedule = @slide.schedules.first
-  end
-
-  def test_valid
-    refute_nil(@slide_schedule)
-    assert_instance_of(Slide::Schedule, @slide_schedule)
-    refute_nil(@slide_schedule.id)
-  end
-
-  #def test_valid_associations
-  #  assert_instance_of(Slide, @slide_schedule.slides.first)
-  #end
-
-end