win32-taskscheduler 1.0.2 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 172397962621f9f6b292f086e64d849feb48a43f52e93beb70e0bbc966bb0b31
-  data.tar.gz: bc1c199304f78f12f7b5a50b00c0b41273a4ecc990e0e1772c6bef37954429f5
+  metadata.gz: 6dbcf68915019eb0cfb32a2fdd4dc7b980dc5b51e9397c5c8dd3ad995a4ff7fc
+  data.tar.gz: e7bc4c68a739975f08a6e726591804e48df0e9d8622d164fdc37818fb615b798
 SHA512:
-  metadata.gz: 68d08019224864d016bc01959287600923f5e452d3b44fe08722d5785d6bc95f966b5f9d6b17ddbd1e1a22bba393b108086363bd91aa37d5821dd497b3cb9ed0
-  data.tar.gz: 716004b5d40cbbb80a0036213411947644f54f2753fbb821937c043f34f596f3311976cf57f5a6521f1e97b4a6d26053a7b4f8c840eaae6192ef2b1ead1ab584
+  metadata.gz: b720b93bfa6fd8628872567f64a82bc6777a707cdf9b0e92de1aca4982b2aa9d79eea3e312cdb3e41e0e8695cb7a807a5e941b20fb9023777613604875993b65
+  data.tar.gz: 6e66aa9252904dfc6ece10372b9c26ea433efbd7f1d20868b032e760a6b783487a14cbd915519f68c4af9b91f0a4a9a783bdf67ca1ae0a07ead4f0370e9d8564

data/CHANGELOG.md

@@ -1,14 +1,36 @@
 # win32-taskscheduler change log
 
-Note: this log contains only changes from win32-taskscheduler release 0.4.1 and later
+Note: this log contains only changes from win32-taskscheduler release 0.4.0 and later
 -- it does not contain the changes from prior releases. To view change history
-prior to release 0.4.1, please visit the [source repository](https://github.com/chef/win32-taskscheduler/commits).
+prior to release 0.4.0, please visit the [source repository](https://github.com/chef/win32-taskscheduler/commits).
 
-<!-- latest_release -->
+<!-- latest_release 1.0.9 -->
+## [win32-taskscheduler-1.0.9](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.9) (2018-07-23)
+
+#### Merged Pull Requests
+- Fix priority should return unique value. [#60](https://github.com/chef/win32-taskscheduler/pull/60) ([Vasu1105](https://github.com/Vasu1105))
 <!-- latest_release -->
 
+<!-- release_rollup since=1.0.2 -->
+### Changes since 1.0.2 release
+
+#### Merged Pull Requests
+- Fix priority should return unique value. [#60](https://github.com/chef/win32-taskscheduler/pull/60) ([Vasu1105](https://github.com/Vasu1105)) <!-- 1.0.9 -->
+- Add DisallowStartIfOnBatteries and StopIfGoingOnBatteries task configs [#61](https://github.com/chef/win32-taskscheduler/pull/61) ([dheerajd-msys](https://github.com/dheerajd-msys)) <!-- 1.0.8 -->
+- [MSYS-827] Add functional test cases  [#58](https://github.com/chef/win32-taskscheduler/pull/58) ([Nimesh-Msys](https://github.com/Nimesh-Msys)) <!-- 1.0.7 -->
+- Remove the Manifest file and add a gitignore file [#57](https://github.com/chef/win32-taskscheduler/pull/57) ([tas50](https://github.com/tas50)) <!-- 1.0.6 -->
+- Add github templates and codeowners file [#52](https://github.com/chef/win32-taskscheduler/pull/52) ([tas50](https://github.com/tas50)) <!-- 1.0.5 -->
+- Remove the cert [#53](https://github.com/chef/win32-taskscheduler/pull/53) ([tas50](https://github.com/tas50)) <!-- 1.0.4 -->
+- MSYS-835 Setup appveyor [#55](https://github.com/chef/win32-taskscheduler/pull/55) ([Vasu1105](https://github.com/Vasu1105)) <!-- 1.0.3 -->
 <!-- release_rollup -->
-<!-- release_rollup -->
+
+<!-- latest_stable_release -->
+## [win32-taskscheduler-1.0.2](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.2) (2018-06-13)
+- Fix for exists? method returning false for task without full path. [#43](https://github.com/chef/win32-taskscheduler/pull/43)([#Vasu1105](https://github.com/Vasu1105))
+- Fix to set user information at the time of creation of task. [#42](https://github.com/chef/win32-taskscheduler/pull/42)([#Vasu1105](https://github.com/Vasu1105))
+- Fix exists? method to find task in given path and if path or folder not present return false. [#40](https://github.com/chef/win32-taskscheduler/pull/40)([#Vasu1105](https://github.com/Vasu1105))
+- Fix for undefined method nil:Nilclass error when force flag is passed to create folder. [#32](https://github.com/chef/win32-taskscheduler/pull/32)([#Vasu1105](https://github.com/Vasu1105))
+
 
 <!-- latest_stable_release -->
 
@@ -16,8 +38,6 @@ prior to release 0.4.1, please visit the [source repository](https://github.com/
 - Fix the issue of "no mapping" while creating Windows task for SYSTEM USERS. [#30](https://github.com/chef/win32-taskscheduler/pull/30) ([#NAshwini](https://github.com/NAshwini))
 - Fix for not to set start time if not set if its 0000-00-00T00:00:00 [#29][(https://github.com/chef/win32-taskscheduler/pull/29) ([#Vasu1105](https://github.com/Vasu1105))
 
-<!-- latest_stable_release -->
-
 
 ## [v0.4.0](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.4.0) (5-Apr-2018)
 - Updated code to create task without trigger. [#25](https://github.com/chef/win32-taskscheduler/pull/25) ([#Vasu1105](https://github.com/Vasu1105))
@@ -140,4 +160,4 @@ prior to release 0.4.1, please visit the [source repository](https://github.com/
   accidentally omitted previously.
 
 ## [v0.0.1](24-Apr-2004)
-- Initial release
+- Initial release

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/clean'
 require 'rake/testtask'
+require 'rspec/core/rake_task'
 
 CLEAN.include("**/*.gem", "**/*.rbc")
 
@@ -24,6 +25,10 @@ task :example do
   ruby '-Iib examples/taskscheduler_example.rb'
 end
 
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList["spec/**/*_spec.rb", "spec/**/**/*_spec.rb"].to_a
+end
+
 desc 'Run the test suite for the win32-taskscheduler library'
 Rake::TestTask.new do |t|
   t.verbose = true

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.9

data/appveyor.yml

@@ -0,0 +1,40 @@
+version: "ole-{build}"
+
+os: Windows server 2012
+platform:
+  - x64
+
+cache:
+  - vendor/bundle
+
+clone_folder: c:\projects\win32-taskscheduler
+clone_depth: 1
+branches:
+  only:
+    - ole
+
+environment:
+  matrix:
+    - ruby_version: "25-x64"
+    - ruby_version: "25"
+    - ruby_version: "24-x64"
+    - ruby_version: "24"
+
+install:
+  - systeminfo
+  - winrm quickconfig -q
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - echo %PATH%
+  - bundle config --local path vendor/bundle # use the cache we define above
+
+build_script:
+  - bundle install || bundle install || bundle install
+
+before_test:
+  - ruby --version
+  - gem --version
+  - bundler --version
+  - bundle env
+
+test_script:
+  - bundle exec rake spec

data/lib/win32/taskscheduler.rb

@@ -121,6 +121,11 @@ module Win32
     attr_accessor :password
     attr_reader :host
 
+
+    def root_path(path = '\\')
+      path
+    end
+
     # Returns a new TaskScheduler object, attached to +folder+. If that
     # folder does not exist, but the +force+ option is set to true, then
     # it will be created. Otherwise an error will be raised. The default
@@ -129,7 +134,7 @@ module Win32
     # If +task+ and +trigger+ are present, then a new task is generated
     # as well. This is effectively the same as .new + #new_work_item.
     #
-    def initialize(task = nil, trigger = nil, folder = "\\", force = false)
+    def initialize(task = nil, trigger = nil, folder = root_path, force = false)
       @folder = folder
       @force  = force
 
@@ -151,14 +156,13 @@ module Win32
 
       @service.Connect
 
-      if folder != "\\"
+      if folder != root_path
         begin
           @root = @service.GetFolder(folder)
         rescue WIN32OLERuntimeError => err
           if force
-            @root = @service.GetFolder("\\")
-            @root.CreateFolder(folder)
-            @root = @service.GetFolder(folder)
+            @root = @service.GetFolder(root_path)
+            @root = @root.CreateFolder(folder)
           else
             raise ArgumentError, "folder '#{folder}' not found"
           end
@@ -197,12 +201,13 @@ module Win32
 
       # Used the splat operator to put all folder elements into path and leave only the task name`
       if full_task_path.include?("\\")
-        *path, task_name = full_task_path.split("\\")
+        full_task_path = root_path + full_task_path
+        *path, task_name = full_task_path.split('\\')
       else
         task_name = full_task_path
       end
 
-      folder = path.nil? ? "\\" : path.join("\\")
+      folder = path.nil? ? root_path : path.join("\\")
 
       begin
         root = @service.GetFolder(folder)
@@ -461,9 +466,9 @@ module Win32
       dir
     end
 
-    # Returns the task's priority level. Possible values are 'idle',
-    # 'normal', 'high', 'realtime', 'below_normal', 'above_normal',
-    # and 'unknown'.
+    # Returns the task's priority level. Possible values are 'idle', 'lowest'.
+    # 'below_normal_8', 'below_normal_7', 'normal_6', 'normal_5', 'normal_4',
+    # 'above_normal_3', 'above_normal_2', 'highest', 'critical' and 'unknown'.
     #
     def priority
       check_for_active_task
@@ -474,19 +479,19 @@ module Win32
         when 1
           priority = 'highest'
         when 2
-          priority = 'above_normal'
+          priority = 'above_normal_2'
         when 3
-          priority = 'above_normal'
+          priority = 'above_normal_3'
         when 4
-          priority = 'normal'
+          priority = 'normal_4'
         when 5
-          priority = 'normal'
+          priority = 'normal_5'
         when 6
-          priority = 'normal'
+          priority = 'normal_6'
         when 7
-          priority = 'below_normal'
+          priority = 'below_normal_7'
         when 8
-          priority = 'below_normal'
+          priority = 'below_normal_8'
         when 9
           priority = 'lowest'
         when 10
@@ -1178,7 +1183,7 @@ module Win32
       definition.Settings.AllowHardTerminate = allow_hard_terminate if allow_hard_terminate
       definition.Settings.Compatibility = compatibility if compatibility
       definition.Settings.DeleteExpiredTaskAfter = delete_expired_task_after if delete_expired_task_after
-      definition.Settings.DisallowStartIfOnBatteries = disallow_start_if_on_batteries if disallow_start_if_on_batteries
+      definition.Settings.DisallowStartIfOnBatteries = disallow_start_if_on_batteries if !disallow_start_if_on_batteries.nil?
       definition.Settings.Enabled = enabled if enabled
       definition.Settings.ExecutionTimeLimit = execution_time_limit if execution_time_limit
       definition.Settings.Hidden = hidden if hidden
@@ -1193,7 +1198,7 @@ module Win32
       definition.Settings.RunOnlyIfIdle = run_only_if_idle if run_only_if_idle
       definition.Settings.RunOnlyIfNetworkAvailable = run_only_if_network_available if run_only_if_network_available
       definition.Settings.StartWhenAvailable = start_when_available if start_when_available
-      definition.Settings.StopIfGoingOnBatteries = stop_if_going_on_batteries if stop_if_going_on_batteries
+      definition.Settings.StopIfGoingOnBatteries  = stop_if_going_on_batteries if !stop_if_going_on_batteries.nil?
       definition.Settings.WakeToRun = wake_to_run if wake_to_run
       definition.Settings.XmlText = xml_text if xml_text
 
@@ -1311,6 +1316,10 @@ module Win32
       symbolize_keys(settings_hash)
     end
 
+    def task_user_id(definition)
+      definition.Principal.UserId
+    end
+
     private
 
     # Returns a camle-case string to its underscore format
@@ -1342,8 +1351,7 @@ module Win32
     end
 
     def update_task_definition(definition)
-      user = definition.Principal.UserId
-
+      user = task_user_id(definition) || 'SYSTEM'
       @task = @root.RegisterTaskDefinition(
         @task.Path,
         definition,

data/lib/win32/taskscheduler/version.rb

@@ -1,6 +1,6 @@
 module Win32
   class TaskScheduler
     # The version of the win32-taskscheduler library
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.0.9'.freeze
   end
 end

data/spec/functional/win32/taskschedular_spec.rb

@@ -0,0 +1,829 @@
+require 'spec_helper'
+require 'win32ole'
+require 'win32/taskscheduler'
+
+RSpec.describe Win32::TaskScheduler, :windows_only do
+  before { create_test_folder }
+  after { clear_them }
+  before { load_task_variables }
+
+  describe '#constructor' do
+    let(:ts) { Win32::TaskScheduler }
+    context 'Task' do
+      it 'Does not creates task when default(nil)' do
+        task = nil
+        expect(ts.new(task)).to be_a(ts)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Does not creates task without trigger' do
+        expect(ts.new(@task)).to be_a(ts)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Creates a task with trigger' do
+        expect(ts.new(@task, @trigger)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+    end
+
+    context 'Trigger' do
+      it 'Does not creates task when default(nil)' do
+        trigger = nil
+        expect(ts.new(@task, trigger)).to be_a(ts)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Raises error without trigger type' do
+        @trigger[:trigger_type] = nil
+        expect { ts.new(@task, @trigger) }.to raise_error(ArgumentError)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Creates a task with trigger type' do
+        expect(ts.new(@task, @trigger)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+    end
+
+    context 'Folder' do
+      let(:folder) { '\\Foo' }
+      it 'Raises error when nil' do
+        expect { ts.new(@task, @trigger, nil) }.to raise_error(NoMethodError)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Raises error when path separators(\\\) are absent' do
+        invalid_path = 'Foo'
+        expect { ts.new(@task, @trigger, invalid_path) }.to raise_error(ArgumentError)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Creates a task when default(root)' do
+        expect(ts.new(@task, @trigger, @folder)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+
+      context 'When force is true' do
+        let(:force) { true }
+        it 'Creates a task at specified folder' do
+          expect(ts.new(@task, @trigger, folder, force)).to be_a(ts)
+          expect(no_of_tasks(folder)).to eq(1)
+        end
+      end
+
+      context 'When force is false' do
+        let(:force) { false }
+        it 'Raises an error when folder does not exists' do
+          expect { ts.new(@task, @trigger, folder, force) }.to raise_error(ArgumentError)
+        end
+
+        it 'Creates a task at specified folder if it exists' do
+          new_folder = @test_folder.CreateFolder(folder)
+          expect(ts.new(@task, @trigger, new_folder.Path, force)).to be_a(ts)
+          expect(no_of_tasks(folder)).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#tasks' do
+    before { create_task }
+    it 'Returns Task Names' do
+      expect(@ts.tasks).to include(@task)
+    end
+
+    it 'is an alias with enum' do
+      expect(@ts.enum).to include(@task)
+    end
+  end
+
+  describe '#exists?' do
+    let(:folder) { '\\Foo' }
+    let(:force) { true }
+    before { create_task }
+
+    context 'valid task path returns true' do
+      it 'at root' do
+        expect(@ts.exists?(@task)).to be_truthy
+      end
+
+      it 'at nested folder' do
+        @ts = Win32::TaskScheduler.new(@task, @trigger, folder, force)
+        task = folder + '\\' + @task
+        expect(@ts.exists?(task)).to be_truthy
+      end
+    end
+
+    context 'invalid task path returns false' do
+      it 'at root' do
+        expect(@ts.exists?('invalid')).to be_falsy
+      end
+
+      it 'at nested folder' do
+        @ts = Win32::TaskScheduler.new(@task, @trigger, folder, force)
+        task = folder + '\\' + 'invalid'
+        expect(@ts.exists?(task)).to be_falsy
+      end
+    end
+  end
+
+  describe '#get_task' do
+    let(:folder) { '\\Foo' }
+    let(:force) { true }
+    before { create_task }
+
+    context 'from root' do
+      it 'Returns the Task if exists' do
+        expect(@ts.get_task(@task)).to be_a(@current_task.class)
+      end
+
+      it 'Raises an error if task does not exists' do
+        expect { @ts.get_task('invalid') }.to raise_error(tasksch_err)
+      end
+    end
+
+    context 'from nested folder' do
+      it 'Returns the Task if exists' do
+        skip 'Implementation Pending'
+      end
+
+      it 'Raises an error if task does not exists' do
+        skip 'Implementation Pending'
+      end
+    end
+  end
+
+  describe '#activate' do
+    let(:folder) { '\\Foo' }
+    let(:force) { true }
+    before { create_task }
+
+    context 'from root' do
+      it 'Activates the Task if exists' do
+        expect(@ts.activate(@task)).to be_a(@current_task.class)
+        expect(@current_task.Enabled).to be_truthy
+      end
+
+      it 'Raises an error if task does not exists' do
+        expect { @ts.activate('invalid') }.to raise_error(tasksch_err)
+      end
+    end
+
+    context 'from nested folder' do
+      it 'Activates the Task if exists' do
+        skip 'Implementation Pending'
+      end
+
+      it 'Raises an error if task does not exists' do
+        skip 'Implementation Pending'
+      end
+    end
+  end
+
+  describe '#delete' do
+    let(:folder) { '\\Foo' }
+    let(:force) { true }
+    before { create_task }
+
+    context 'from root' do
+      it 'Deletes the Task if exists' do
+        expect(no_of_tasks).to eq(1)
+        @ts.delete(@task)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'Raises an error if task does not exists' do
+        expect { @ts.delete('invalid') }.to raise_error(tasksch_err)
+      end
+    end
+
+    context 'from nested folder' do
+      it 'Activates the Task if exists' do
+        skip 'Implementation Pending'
+      end
+
+      it 'Raises an error if task does not exists' do
+        skip 'Implementation Pending'
+      end
+    end
+  end
+
+  describe '#run' do
+    before { create_task }
+    after { stop_the_app }
+
+    it 'Execute(Start) the Task' do
+      @ts.run
+      expect(@ts.status).to eq('running').
+                         or eq('queued').
+                         or eq('ready') # It takes time to load sometimes
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.run }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#terminate' do
+    before { create_task }
+    after { stop_the_app }
+
+    it 'terminates the Task if exists' do
+      @ts.terminate
+      expect(@ts.status).to eq('ready')
+    end
+
+    it 'has an alias stop' do
+      @ts.stop
+      expect(@ts.status).to eq('ready')
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.terminate }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#application_name' do
+    before { create_task }
+    it 'Returns the application name of task' do
+      check = @app
+      expect(@ts.application_name).to eq(check)
+    end
+
+    it 'Sets the application name of task' do
+      stub_user
+      check = 'cmd.exe'
+      expect(@ts.application_name = check).to eq(check)
+      expect(@ts.application_name).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.application_name }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#parameters' do
+    before { create_task }
+    it 'Returns the parameters of task' do
+      check = ''
+      expect(@ts.parameters).to eq(check)
+    end
+
+    it 'Sets the parameters of task' do
+      stub_user
+      check = 'cmd.exe'
+      expect(@ts.parameters = check).to eq(check)
+      expect(@ts.parameters).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.parameters }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#working_directory' do
+    before { create_task }
+    it 'Returns the working directory of task' do
+      check = ''
+      expect(@ts.working_directory).to eq(check)
+    end
+
+    it 'Sets the working directory of task' do
+      stub_user
+      check = Dir.pwd
+      expect(@ts.working_directory = check).to eq(check)
+      expect(@ts.working_directory).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.working_directory }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#priority' do
+    before { create_task }
+    it 'Returns default priority of task' do
+      check = 'below_normal_7'
+      expect(@ts.priority).to eq(check)
+    end
+
+    it '0 Sets the priority of task to critical' do
+      stub_user
+      check = 0
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('critical')
+    end
+
+    it '1 Sets the priority of task to highest' do
+      stub_user
+      check = 1
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('highest')
+    end
+
+    it '2 Sets the priority of task to above_normal_2' do
+      stub_user
+      check = 2
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('above_normal_2')
+    end
+
+    it '3 Sets the priority of task to above_normal_3' do
+      stub_user
+      check = 3
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('above_normal_3')
+    end
+
+    it '4 Sets the priority of task to normal_4' do
+      stub_user
+      check = 4
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('normal_4')
+    end
+
+    it '5 Sets the priority of task to normal_5' do
+      stub_user
+      check = 5
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('normal_5')
+    end
+
+    it '6 Sets the priority of task to normal_6' do
+      stub_user
+      check = 6
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('normal_6')
+    end
+
+    it '7 Sets the priority of task to below_normal_7' do
+      stub_user
+      check = 7
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('below_normal_7')
+    end
+
+    it '8 Sets the priority of task to below_normal_8' do
+      stub_user
+      check = 8
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('below_normal_8')
+    end
+
+    it '9 Sets the priority of task to lowest' do
+      stub_user
+      check = 9
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('lowest')
+    end
+
+    it '10 Sets the priority of task to idle' do
+      stub_user
+      check = 10
+      expect(@ts.priority = check).to eq(check)
+      expect(@ts.priority).to eq('idle')
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.priority }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#comment' do
+    before { create_task }
+    it 'Returns the comment of task' do
+      check = 'Sample task for testing purpose'
+      expect(@ts.comment).to eq(check)
+    end
+
+    it 'Sets the Comment(Description) of task' do
+      stub_user
+      check = 'Description To Test'
+      expect(@ts.comment = check).to eq(check)
+      expect(@ts.comment).to eq(check)
+    end
+
+    it 'alias with Description' do
+      stub_user
+      check = 'Description To Test'
+      expect(@ts.description = check).to eq(check)
+      expect(@ts.comment).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.comment }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#author' do
+    before { create_task }
+    it 'Returns the author of task' do
+      check = 'Rspec'
+      expect(@ts.author).to eq(check)
+    end
+
+    it 'Sets the Author of task' do
+      stub_user
+      check = 'Author'
+      expect(@ts.author = check).to eq(check)
+      expect(@ts.author).to eq(check)
+    end
+
+    it 'alias with Creator' do
+      stub_user
+      check = 'Description To Test'
+      expect(@ts.creator = check).to eq(check)
+      expect(@ts.author).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.author }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#max_run_time' do
+    before { create_task }
+    it 'Returns the Execution Time Limit of task' do
+      skip 'Due to logical error in implementation'
+      check = (72 * 60 * 60) # Task: PT72H
+      expect(@ts.max_run_time).to eq(check)
+    end
+
+    it 'Sets the max_run_time of task' do
+      skip 'Due to logical error in implementation'
+      check = 1_244_145_000_000
+      expect(@ts.max_run_time = check).to eq(check)
+      expect(@ts.max_run_time).to eq(check)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.max_run_time }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#enabled?' do
+    before { create_task }
+    it 'Returns true when Task is enabled' do
+      expect(@ts.enabled?).to be_truthy
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.enabled? }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#next_run_time' do
+    before { create_task }
+    it 'Returns a Time object that indicates the next time the task will run' do
+      expect(@ts.next_run_time).to be_a(Time)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.next_run_time }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#most_recent_run_time' do
+    before { create_task }
+
+    it 'Returns nil if the task has never run' do
+      skip 'Error in implementation; Time.parse requires String'
+      expect(@ts.most_recent_run_time).to be_nil
+    end
+
+    it 'Returns Time object indicating the most recent time the task ran' do
+      skip 'Error in implementation; Time.parse requires String'
+      @ts.run
+      expect(@ts.most_recent_run_time).to be_a(Time)
+      @ts.stop
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.most_recent_run_time }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#account_information' do
+    before { create_task }
+    it 'System users may not require any password' do
+      user = 'SYSTEM'
+      password = nil
+      expect(@ts.set_account_information(user, password)). to be_truthy
+      expect(@ts.account_information).to eq(user)
+    end
+
+    it 'User will require a password' do
+      user = ENV['user']
+      password = nil
+      expect { @ts.set_account_information(user, password) }. to raise_error(TypeError)
+      expect(@ts.account_information).to include(user)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      user = 'User'
+      password = 'XXXX'
+      expect { @ts.set_account_information(user, password) }. to raise_error(tasksch_err)
+      expect(@ts.account_information).to be_nil
+    end
+  end
+
+  describe '#status' do
+    before { create_task }
+    it 'Returns tasks status' do
+      expect(@ts.status).to be_a(String)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.status }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#exit_code' do
+    before { create_task }
+    it 'Returns the exit code from the last scheduled run' do
+      expect(@ts.exit_code).to be_a(Integer)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.exit_code }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#trigger_count' do
+    before { create_task }
+    it 'Returns No of triggers associated with the task' do
+      expect(@ts.trigger_count).to eq(1)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.trigger_count }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#trigger_string' do
+    before { create_task }
+    it 'Returns a string that describes the current trigger at '\
+       'the specified index for the active task' do
+      expect(@ts.trigger_string(0)).to be_a(String)
+    end
+
+    it 'Raises an error if trigger is not found at the given index' do
+      expect { @ts.trigger_string(1) }.to raise_error(tasksch_err)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.trigger_string(0) }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#idle_settings' do
+    before { create_task }
+    it 'Returns a hash containing idle settings of the current task' do
+      settings = @ts.idle_settings
+      expect(settings).to be_a(Hash)
+      expect(settings).to include(stop_on_idle_end: true)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.idle_settings }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#network_settings' do
+    before { create_task }
+    it 'Returns a hash containing network settings of the current task' do
+      settings = @ts.network_settings
+      expect(settings).to be_a(Hash)
+      expect(settings).to include(name: '')
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.network_settings }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#settings' do
+    before { create_task }
+    it 'Returns a hash containing all the settings of the current task' do
+      settings = @ts.settings
+      expect(settings).to be_a(Hash)
+      expect(settings).to include(enabled: true)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.settings }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#configure_settings' do
+    before { create_task }
+    before { stub_user }
+
+    it 'Sets idle settings of the task' do
+      skip 'Functionality is not working'
+      # Seems like it accepts time in minutes; but returns the result in ISO8601 format
+      settings = { idle_duration: 'PT11M',
+                   wait_timeout: 'PT2H',
+                   stop_on_idle_end: true,
+                   restart_on_idle: false }
+      @ts.configure_settings(settings)
+      expect(@ts.idle_settings).to eq(settings)
+    end
+
+    it 'Sets network settings of the task' do
+      skip 'Functionality is not working'
+      settings = { network_settings: { name: 'NET1' } }
+      @ts.configure_settings(settings)
+      expect(@ts.network_settings).to eq(settings)
+    end
+
+    it 'Configures the settings of the task' do
+      skip 'Functionality is not working properly'
+      settings = @ts.settings
+      settings[:allow_demand_start] = false
+      settings[:execution_time_limit] = 'PT70H'
+      @ts.configure_settings(settings)
+      expect(@ts.settings).to eq(settings)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.settings }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#principals' do
+    before { create_task }
+    it 'Returns a hash containing all the principal information of the current task' do
+      principals = @ts.principals
+      expect(principals).to be_a(Hash)
+      expect(principals).to include(id: 'Author')
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.principals }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#principals' do
+    before { create_task }
+    it 'Returns a hash containing all the principal information of the current task' do
+      principals = @ts.principals
+      expect(principals).to be_a(Hash)
+      expect(principals).to include(id: 'Author')
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.principals }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#configure_principals' do
+    before { create_task }
+    before { stub_user }
+
+    it 'Sets the principals for current active task' do
+      principals = @ts.principals
+      principals[:user_id] = 'SYSTEM'
+      principals[:display_name] = 'Rspec'
+      principals[:run_level] = Win32::TaskScheduler::TASK_RUNLEVEL_HIGHEST
+      principals[:logon_type] = Win32::TaskScheduler::TASK_LOGON_SERVICE_ACCOUNT
+
+      @ts.configure_principals(principals)
+      expect(@ts.principals).to eq(principals)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.principals }. to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#trigger' do
+    before { create_task }
+
+    it 'Returns a hash that describes the trigger '\
+       'at the given index for the current task' do
+      trigger = @ts.trigger(0)
+      expect(trigger).to be_a(Hash)
+      expect(trigger).not_to be_empty
+    end
+
+    it 'Raises an error if trigger is not found at the given index' do
+      expect { @ts.trigger(1) }.to raise_error(tasksch_err)
+    end
+
+    it 'Raises an error if task does not exists' do
+      @ts.instance_variable_set(:@task, nil)
+      expect { @ts.trigger(0) }.to raise_error(tasksch_err)
+    end
+  end
+
+  describe '#trigger=' do
+    before { create_task }
+    before { stub_user }
+    all_triggers.each do |type, trigger_hash|
+      it "Updates the first trigger for type: #{type}" do
+        @ts.trigger = trigger_hash
+        returned_trigger = @ts.trigger(0)
+        expect(returned_trigger).to eq(trigger_hash)
+        expect(@ts.trigger_count).to eq(1)
+      end
+
+      it "Updates the trigger at given index for type: #{type}" do
+        skip 'Implementation Pending'
+        @ts.trigger = trigger_hash
+        returned_trigger = @ts.trigger(0)
+        expect(returned_trigger).to eq(trigger_hash)
+        expect(@ts.trigger_count).to eq(1)
+      end
+
+      it 'Raises an error if task does not exists' do
+        @ts.instance_variable_set(:@task, nil)
+        expect { @ts.trigger = trigger_hash }.to raise_error(tasksch_err)
+      end
+    end
+  end
+
+  describe '#new_work_item' do
+    before { create_task }
+    context 'Creates a new task' do
+      all_triggers.each do |type, trigger_hash|
+        it "for the triger: #{type}" do
+          task_count = 1 # One task already exists
+          expect(@ts.new_work_item("Task_#{type}", trigger_hash)).to be_a(@current_task.class)
+          task_count += 1
+          expect(no_of_tasks).to eq(task_count)
+        end
+      end
+    end
+
+    context 'Updates the existing task' do
+      all_triggers.each do |type, trigger_hash|
+        it "for the triger: #{type}" do
+          expect(@ts.new_work_item(@task, trigger_hash)).to be_a(@current_task.class)
+          expect(no_of_tasks).to eq(1)
+        end
+
+        it 'Raises an error if task does not exists' do
+          @ts.instance_variable_set(:@task, nil)
+          expect { @ts.trigger = trigger_hash }.to raise_error(tasksch_err)
+        end
+      end
+    end
+  end
+
+  private
+
+  def load_task_variables
+    time = Time.now
+    # Ensuring root path will be test path
+    allow_any_instance_of(Win32::TaskScheduler).to receive(:root_path).and_return(@test_path)
+    @app = 'iexplore.exe'
+    @task = 'test_task'
+    @folder = @test_path
+    @force = false
+    @trigger = { start_year: time.year, start_month: time.month,
+                 start_day: time.day, start_hour: time.hour,
+                 start_minute: time.min,
+                 # Will update this in test cases when required
+                 trigger_type: Win32::TaskScheduler::ONCE }
+    @ts = Win32::TaskScheduler.new
+  end
+
+  # Sets the user Id as nil, hence SYSTEM will be considered
+  # Alternatively, we may to provide the login users password
+  def stub_user
+    # @ts.instance_variable_set(:@password, 'user_login_password')
+    allow(@ts).to receive(:task_user_id).and_return(nil)
+  end
+
+  # Will stop the appliaction only if it is running
+  def stop_the_app
+    `tasklist /FI "IMAGENAME eq #{@app}" 2>NUL | find /I /N "#{@app}">NUL
+    if "%ERRORLEVEL%"=="0" taskkill /f /im #{@app}`
+  end
+end