RubyGems - lws - Versions diffs - 8.1.0 → 9.0.0.beta1 - Mend

lws 8.1.0 → 9.0.0.beta1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

checksums.yaml +4 -4
data/lib/lws/version.rb +1 -1
metadata +21 -65
data/test/api_token_middleware_test.rb +0 -59
data/test/auth_test.rb +0 -190
data/test/caching_test.rb +0 -65
data/test/config/empty.yml +0 -2
data/test/config/endpoints.yml +0 -4
data/test/config/full.yml +0 -16
data/test/config/invalid.yml +0 -3
data/test/config/switch_env.yml +0 -3
data/test/config/tokens.yml +0 -3
data/test/corporate_website_test.rb +0 -113
data/test/digital_signage_test.rb +0 -980
data/test/fixtures/auth.yml +0 -73
data/test/fixtures/permissions.yml +0 -27
data/test/generic_test.rb +0 -179
data/test/http_caching_test.rb +0 -82
data/test/json_parser_test.rb +0 -92
data/test/logger_test.rb +0 -36
data/test/maps_test.rb +0 -78
data/test/presence_test.rb +0 -205
data/test/resource_test.rb +0 -91
data/test/setup_test.rb +0 -177
data/test/stubbing_test.rb +0 -74
data/test/support/with_env.rb +0 -25
data/test/test_helper.rb +0 -77
data/test/ticket_test.rb +0 -131

data/test/digital_signage_test.rb DELETED Viewed

@@ -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