win32-taskscheduler 1.0.2 → 1.0.9

data/spec/spec_helper.rb

@@ -1 +1,224 @@
-$LOAD_PATH.unshift File.expand_path('../lib/win32', __dir__)
+libx = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(libx) unless $LOAD_PATH.include?(libx)
+
+require 'date'
+
+# In order to test some dummy task and folder, we are creating
+# 'Test' folder and consider it as 'root'.
+# After the test case, all the above created elements
+# i.e, 'Test', Tasks and nested folders will be deleted.
+# It will ensure No Harm be caused to any existing tasks at root
+
+# Creating folder 'Test'; This will be treated as root
+def create_test_folder
+  @service ||= service
+  @root_path = '\\'
+  @test_path = '\\Test'
+  @root_folder = @service.GetFolder(@root_path)
+  @test_folder = @root_folder.CreateFolder(@test_path)
+  @ts.instance_variable_set(:@root, @test_folder) if @ts
+end
+
+# Deleting the test folder its nested folder(if any)
+# And the tasks within(if any)
+def clear_them
+  if @test_folder
+    delete_all(@test_folder)
+  else
+    @test_folder = nil
+  end
+end
+
+# Logic to delete tasks and folder using Win32OLE methods
+def delete_all(folder)
+  delete_tasks_in(folder)
+  folder.GetFolders(0).each do |nested_folder|
+    delete_all(nested_folder)
+  end
+  @root_folder.DeleteFolder(folder.Path, 0)
+end
+
+# Deleting the task in specified folder using Win32OLE methods
+def delete_tasks_in(folder)
+  folder.GetTasks(0).each do |task|
+    folder.DeleteTask(task.Name, 0)
+  end
+end
+
+# Returns Win32 Service object
+def service
+  service = WIN32OLE.new('Schedule.Service')
+  service.Connect
+  service
+end
+
+# Returns no of task in the specified folder
+def no_of_tasks(folder = @test_folder)
+  if folder.is_a?(String)
+    folder = @test_path + folder
+    folder = @service.GetFolder(folder)
+  end
+  folder.GetTasks(0).Count
+end
+
+# Steps to create (Register) a task
+# This is an example activity to test
+# the related functionalities over a task in RSpecs
+def create_task
+  return nil unless @service
+  @task_definition = @service.NewTask(0)
+  task_registration
+  task_prinicipals
+  task_settings
+  task_triggers
+  task_action
+  register_task
+end
+
+def task_registration
+  reg_info = @task_definition.RegistrationInfo
+  reg_info.Description = 'Sample task for testing purpose'
+  reg_info.Author = 'Rspec'
+end
+
+def task_prinicipals
+  principal = @task_definition.Principal
+  principal.LogonType = 3 # Interactive Logon
+end
+
+def task_settings
+  settings = @task_definition.Settings
+  settings.Enabled = true
+  settings.StartWhenAvailable = true
+  settings.Hidden = false
+end
+
+def task_triggers
+  triggers = @task_definition.Triggers
+  trigger = triggers.Create(1) # Time
+  start_time, end_time = start_end_time
+  trigger.StartBoundary = start_time
+  trigger.EndBoundary = end_time
+  trigger.ExecutionTimeLimit = 'PT5M' # Five minutes
+  trigger.Id = 'TimeTriggerId'
+  trigger.Enabled = true
+end
+
+def task_action
+  action = @task_definition.Actions.Create(0)
+  action.Path = @app
+end
+
+# Registering(Creating) a task in test folder
+def register_task
+  @current_task = @test_folder.RegisterTaskDefinition(
+    @task, # Name of the task
+    @task_definition, # Definition
+    6, # Flag: TASK_CREATE_OR_UPDATE
+    nil, # UserId
+    nil, # Password
+    3
+  )
+  @ts.instance_variable_set(:@task, @current_task) if @ts
+end
+
+def start_end_time
+  t = Date.new(2010)
+  start_time = t.strftime('%FT%T')
+  end_time = (t + 5).strftime('%FT%T') # 5 Days
+  [start_time, end_time]
+end
+
+def tasksch_err
+  Win32::TaskScheduler::Error
+end
+
+# Methods to build all types of triggers and their values
+
+def all_triggers
+  all_triggers = {}
+
+  %w[ONCE DAILY WEEKLY MONTHLYDATE MONTHLYDOW
+     ON_IDLE AT_SYSTEMSTART AT_LOGON].each do |trig_type|
+    trigger = {}
+    trigger[:trigger_type] = Win32::TaskScheduler.class_eval(trig_type)
+    start_end_params(trigger)
+    other_trigger_params(trig_type, trigger)
+    all_triggers[trig_type] = trigger
+  end
+
+  all_triggers
+end
+
+def start_end_params(trigger)
+  %i[start_year end_year].each do |t|
+    trigger[t] = '2030'
+  end
+
+  %i[start_month start_day start_hour start_minute].each do |t|
+    trigger[t] = '02'
+  end
+
+  %i[end_day end_month].each do |t|
+    trigger[t] = '03'
+  end
+
+  %i[minutes_duration minutes_interval].each do |t|
+    trigger[t] = 2
+  end
+end
+
+def other_trigger_params(trig_type, trigger)
+  type = {}
+  case trig_type
+  when 'ONCE'
+    trigger[:type] = type
+    type[:once] = nil
+    trigger[:random_minutes_interval] = 2
+  when 'DAILY'
+    trigger[:type] = type
+    type[:days_interval] = 2
+    trigger[:random_minutes_interval] = 2
+  when 'WEEKLY'
+    trigger[:type] = type
+    type[:weeks_interval] = 2
+    type[:days_of_week] = sunday
+    trigger[:random_minutes_interval] = 2
+  when 'MONTHLYDATE'
+    trigger[:type] = type
+    type[:months] = january
+    type[:days] = first_day
+    trigger[:run_on_last_day_of_month] = false
+    trigger[:random_minutes_interval] = 2
+  when 'MONTHLYDOW'
+    trigger[:type] = type
+    type[:months] = january
+    type[:days_of_week] = sunday
+    type[:weeks_of_month] = first_week
+    trigger[:run_on_last_week_of_month] = false
+    trigger[:random_minutes_interval] = 2
+  when 'ON_IDLE'
+    trigger[:execution_time_limit] = 2
+  when 'AT_SYSTEMSTART'
+    trigger[:delay_duration] = 2
+  when 'AT_LOGON'
+    trigger[:user_id] = 'SYSTEM'
+    trigger[:delay_duration] = 2
+  end
+end
+
+def sunday
+  Win32::TaskScheduler::SUNDAY
+end
+
+def january
+  Win32::TaskScheduler::JANUARY
+end
+
+def first_day
+  Win32::TaskScheduler::FIRST
+end
+
+def first_week
+  Win32::TaskScheduler::FIRST_WEEK
+end

data/spec/unit/win32/taskschedular_spec.rb

@@ -0,0 +1,132 @@
+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 'no of arguments' do
+      it 'zero' do
+        expect(ts.new).to be_a(ts)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'one: task' do
+        expect(ts.new(@task)).to be_a(ts)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'two: task, trigger; trigger_type is blank' do
+        @trigger[:trigger_type] = nil
+        expect { ts.new(@task, @trigger) }.to raise_error(ArgumentError)
+        expect(no_of_tasks).to eq(0)
+      end
+
+      it 'two: task, trigger; trigger_type is not blank; Creates a task' do
+        expect(ts.new(@task, @trigger)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+
+      it 'three: task, trigger, folder; Creates a task' do
+        expect(ts.new(@task, @trigger, @folder)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+
+      it 'four: task, trigger, folder, force; Creates a task' do
+        expect(ts.new(@task, @trigger, @folder, @force)).to be_a(ts)
+        expect(no_of_tasks).to eq(1)
+      end
+
+      it 'raises an error for more than four arguments' do
+        expect { ts.new(@task, @trigger, @folder, @force, 1) }.to raise_error(ArgumentError)
+        expect { ts.new(@task, @trigger, @folder, @force, 'abc') }.to raise_error(ArgumentError)
+        expect(no_of_tasks).to eq(0)
+      end
+    end
+  end
+
+  describe '#Tasks' do
+    before { create_task }
+    it 'Returns an Array' do
+      expect(@ts.tasks).to be_a(Array)
+    end
+
+    it 'Returns an Empty Array if no task is present' do
+      delete_tasks_in(@test_folder)
+      expect(@ts.tasks).to be_empty
+    end
+  end
+
+  describe '#exists?' do
+    let(:folder) { '\\Foo' }
+    let(:force) { true }
+    before { create_task }
+
+    context 'At Root' do
+      it 'Requires only task name' do
+        expect(@ts.exists?(@task)).to be_truthy
+      end
+
+      it 'Does not require root to be appended' do
+        task = @folder + '\\' + @task
+        expect(@ts.exists?(task)).to be_falsey
+      end
+    end
+
+    context 'At Nested folder' do
+      it 'Returns false for non existing folder' do
+        task = folder + '\\' + @task
+        expect(@ts.exists?(task)).to be_falsey
+      end
+
+      it 'Returns true for existing folder' do
+        @ts = Win32::TaskScheduler.new(@task, @trigger, folder, force)
+        task = folder + '\\' + @task
+        expect(@ts.exists?(task)).to be_truthy
+      end
+    end
+  end
+
+  describe '#get_task' do
+    before { create_task }
+    it 'Requires a string: Task Name' do
+      expect { @ts.get_task(0) }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#activate' do
+    before { create_task }
+    it 'Requires a string: Task Name' do
+      expect { @ts.activate(0) }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#delete' do
+    before { create_task }
+    it 'Requires a string: Task Name' do
+      expect { @ts.delete(0) }.to raise_error(TypeError)
+    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 = 'notepad.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
+end

data/spec/unit/win32/windows/constants_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'win32/taskscheduler'
+require 'win32/windows/constants'
+
+RSpec.describe Win32::TaskScheduler, :windows_only do
+  describe 'Ensuring trigger constants' do
+    subject(:ts) { Win32::TaskScheduler }
+    describe 'to handle scheduled tasks' do
+      [:ONCE, :DAILY, :WEEKLY, :MONTHLYDATE, :MONTHLYDOW].each do |const|
+        it { should be_const_defined(const) }
+      end
+    end
+
+    describe 'to handle other types' do
+      [:AT_LOGON, :AT_SYSTEMSTART, :ON_IDLE].each do |const|
+        it { should be_const_defined(const) }
+      end
+    end
+  end
+end

data/spec/unit/win32/windows/time_calc_helper_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'win32/windows/time_calc_helper'
+
+RSpec.describe Windows::TimeCalcHelper do
+  let(:object) { klass.new }
+  let(:klass) do
+    Class.new do
+      include Windows::TimeCalcHelper
+    end
+  end
+
+  describe '#is_leap_year?' do
+    it 'require an year in integer format' do
+      expect { object.is_leap_year? }.to raise_error(ArgumentError)
+      expect { object.is_leap_year?('year') }.to raise_error(NoMethodError)
+    end
+
+    it 'returns true for leap years' do
+      year = 2000
+      expect(object.is_leap_year?(year)).to be_truthy
+      year = 2004
+      expect(object.is_leap_year?(year)).to be_truthy
+    end
+
+    it 'returns false for non-leap years' do
+      year = 1900
+      expect(object.is_leap_year?(year)).to be_falsy
+      year = 2001
+      expect(object.is_leap_year?(year)).to be_falsy
+    end
+  end
+
+  describe '#days_in_month' do
+    it 'require month and year in integer format' do
+      expect { object.days_in_month }.to raise_error(ArgumentError)
+      expect { object.days_in_month('month', 'year') }.to raise_error(TypeError)
+    end
+
+    context 'leap year' do
+      year = 2000
+      it 'January will have 31 days' do
+        month = 1
+        expect(object.days_in_month(month, year)).to eql(31)
+      end
+
+      it 'February will have 29 days' do
+        month = 2
+        expect(object.days_in_month(month, year)).to eql(29)
+      end
+
+      it 'November will have 30 days' do
+        month = 11
+        expect(object.days_in_month(month, year)).to eql(30)
+      end
+    end
+
+    context 'non-leap year' do
+      year = 2003
+      it 'January will have 31 days' do
+        month = 1
+        expect(object.days_in_month(month, year)).to eql(31)
+      end
+
+      it 'February will have 28 days' do
+        month = 2
+        expect(object.days_in_month(month, year)).to eql(28)
+      end
+
+      it 'November will have 30 days' do
+        month = 11
+        expect(object.days_in_month(month, year)).to eql(30)
+      end
+    end
+  end
+
+  describe '#time_details' do
+    it 'require a time string in String format' do
+      expect { object.time_details }.to raise_error(ArgumentError)
+      expect { object.time_details(1234) }.to raise_error(TypeError)
+    end
+
+    it 'returns an empty hash if no string is passed' do
+      expect(object.time_details(nil)).to be_a(Hash)
+      expect(object.time_details(nil)).to be_empty
+    end
+
+    context 'of MSDN time string' do
+      it 'returns hash with date' do
+        time_str = 'P10Y10M10D'
+        time_hsh = { year: '10', month: '10', day: '10' }
+        expect(object.time_details(time_str)).to eq(time_hsh)
+      end
+
+      it 'returns hash with time' do
+        time_str = 'PT10H10M10S'
+        time_hsh = { hour: '10', min: '10', sec: '10' }
+        expect(object.time_details(time_str)).to eq(time_hsh)
+      end
+
+      it 'returns hash with date-time' do
+        time_str = 'P10Y10M10DT10H10M10S'
+        time_hsh = { year: '10', month: '10', day: '10',
+                     hour: '10', min: '10', sec: '10' }
+        expect(object.time_details(time_str)).to eq(time_hsh)
+      end
+    end
+  end
+
+  describe '#time_in_seconds' do
+    it 'require a time string in String format' do
+      expect { object.time_in_seconds }.to raise_error(ArgumentError)
+      expect { object.time_in_seconds(1234) }.to raise_error(TypeError)
+    end
+
+    it 'returns zero if no string is passed' do
+      expect(object.time_in_seconds(nil)).to be_zero
+    end
+
+    context 'in leap year' do
+      before do
+        time_now = Time.new(2004)
+        allow(Time).to receive(:now).and_return(time_now)
+      end
+
+      it 'returns seconds for date' do
+        time_str = 'P10Y10M10D'
+        expect(object.time_in_seconds(time_str)).to eq(342_748_800)
+      end
+
+      it 'returns seconds for time' do
+        time_str = 'PT10H10M10S'
+        expect(object.time_in_seconds(time_str)).to eq(36_610)
+      end
+
+      it 'returns seconds for date-time' do
+        time_str = 'P10Y10M10DT10H10M10S'
+        expect(object.time_in_seconds(time_str)).to eq(342_785_410)
+      end
+    end
+    context 'in non-leap year' do
+      before do
+        time_now = Time.new(2003)
+        allow(Time).to receive(:now).and_return(time_now)
+      end
+
+      it 'returns seconds for date' do
+        time_str = 'P10Y10M10D'
+        expect(object.time_in_seconds(time_str)).to eq(342_748_800)
+      end
+
+      it 'returns seconds for time' do
+        time_str = 'PT10H10M10S'
+        expect(object.time_in_seconds(time_str)).to eq(36_610)
+      end
+
+      it 'returns seconds for date-time' do
+        time_str = 'P10Y10M10DT10H10M10S'
+        expect(object.time_in_seconds(time_str)).to eq(342_785_410)
+      end
+    end
+  end
+
+  describe '#time_in_minutes' do
+    it 'require a time string in String format' do
+      expect { object.time_in_minutes }.to raise_error(ArgumentError)
+      expect { object.time_in_minutes(1234) }.to raise_error(TypeError)
+    end
+
+    it 'returns zero if no string is passed' do
+      expect(object.time_in_minutes(nil)).to be_zero
+    end
+
+    context 'in leap year' do
+      before do
+        time_now = Time.new(2004)
+        allow(Time).to receive(:now).and_return(time_now)
+      end
+
+      it 'returns minutes for date' do
+        time_str = 'P10Y10M10D'
+        expect(object.time_in_minutes(time_str)).to eq(5_712_480)
+      end
+
+      it 'returns minutes for time' do
+        time_str = 'PT10H10M10S'
+        expect(object.time_in_minutes(time_str)).to eq(610)
+      end
+
+      it 'returns minutes for date-time' do
+        time_str = 'P10Y10M10DT10H10M10S'
+        expect(object.time_in_minutes(time_str)).to eq(5_713_090)
+      end
+    end
+
+    context 'in non-leap year' do
+      before do
+        time_now = Time.new(2003)
+        allow(Time).to receive(:now).and_return(time_now)
+      end
+
+      it 'returns minutes for date' do
+        time_str = 'P10Y10M10D'
+        expect(object.time_in_minutes(time_str)).to eq(5_712_480)
+      end
+
+      it 'returns minutes for time' do
+        time_str = 'PT10H10M10S'
+        expect(object.time_in_minutes(time_str)).to eq(610)
+      end
+
+      it 'returns minutes for date-time' do
+        time_str = 'P10Y10M10DT10H10M10S'
+        expect(object.time_in_minutes(time_str)).to eq(5_713_090)
+      end
+    end
+  end
+end