lws 0.4.2 → 6.1.0.beta1

data/test/digital_signage_test.rb

@@ -0,0 +1,829 @@
+#
+# Copyright © 2016 LeftClick B.V.
+#
+# This software is property of LeftClick 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 B.V. at:  Geldropseweg 8B, 5731 SG Mierlo, The
+# Netherlands, info@leftclick.eu, +31492-782120.
+
+
+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)
+    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)
+    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.all.first
+  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.all.first
+    # 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.all.first
+  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.all.first
+  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.all.first
+    # 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 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 TestDigitalSignagePlayerFeedback < MiniTest::Test
+
+  include LWS::DigitalSignage
+
+  def setup
+    @player = Player.find(1)
+    # Player feedbacks only exist as child objects of players
+    @player_feedback = @player.feedbacks.first
+  end
+
+  def test_valid
+    refute_nil(@player_feedback)
+    assert_instance_of(Player::Feedback, @player_feedback)
+    refute_nil(@player_feedback.id)
+  end
+
+  def test_valid_associations
+    assert_instance_of(Player, @player_feedback.player)
+    assert_equal(@player, @player_feedback.player)
+    # FIXME: Missing branch_id field in LWS
+    #assert_instance_of(Player::Os::Branch::Release, @player_feedback.release)
+    # FIXME: Chained associations don't work yet in Spyke (#89)
+    #assert_instance_of(Player::Feedback::Result, @player_feedback.results.first)
+  end
+
+end
+
+class TestDigitalSignagePlayerFeedbackResult < MiniTest::Test
+
+  include LWS::DigitalSignage
+
+  def setup
+    @player = Player.find(1)
+    # Player feedbacks only exist as decendant objects of players
+    @player_feedback = @player.feedbacks.all.first
+    # Player feedback results only exist as decendant objects of player
+    # feedbacks
+    # FIXME: Chained associations don't work yet in Spyke (#89)
+    #@player_feedback_result = @player_feedback.results.first
+  end
+
+  # FIXME: Chained associations don't work yet in Spyke (#89)
+  #def test_valid
+  #  refute_nil(@player_feedback_result)
+  #  assert_instance_of(Player::Feedback::Result, @player_feedback_result)
+  #  refute_nil(@player_feedback_result.id)
+  #end
+
+  # FIXME: Chained associations don't work yet in Spyke (#89)
+  #def test_valid_associations
+  #  assert_instance_of(Player, @player_feedback_result.player)
+  #  assert_equal(@player_feedback, @player_feedback_result.player)
+  #  assert_instance_of(Player::Feedback, @player_feedback_result.feedback)
+  #  assert_equal(@player_feedback, @player_feedback_result.feedback)
+  #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)
+    if @player_request.processed
+      if @player_request.feedback.present?
+        assert_instance_of(Player::Feedback, @player_request.feedback)
+      elsif @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