subscription_test.go

Documentation: github.com/coreos/go-systemd/v22/dbus

     1  // Copyright 2015 CoreOS, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package dbus
    16  
    17  import (
    18  	"testing"
    19  	"time"
    20  )
    21  
    22  // TestSubscribe exercises the basics of subscription
    23  func TestSubscribe(t *testing.T) {
    24  	conn, err := New()
    25  
    26  	if err != nil {
    27  		t.Fatal(err)
    28  	}
    29  
    30  	err = conn.Subscribe()
    31  	if err != nil {
    32  		t.Fatal(err)
    33  	}
    34  
    35  	err = conn.Unsubscribe()
    36  	if err != nil {
    37  		t.Fatal(err)
    38  	}
    39  }
    40  
    41  // TestSubscribeUnit exercises the basics of subscription of a particular unit.
    42  func TestSubscribeUnit(t *testing.T) {
    43  	target := "subscribe-events.service"
    44  
    45  	conn, err := New()
    46  
    47  	if err != nil {
    48  		t.Fatal(err)
    49  	}
    50  
    51  	err = conn.Subscribe()
    52  	if err != nil {
    53  		t.Fatal(err)
    54  	}
    55  
    56  	err = conn.Unsubscribe()
    57  	if err != nil {
    58  		t.Fatal(err)
    59  	}
    60  
    61  	evChan, errChan := conn.SubscribeUnits(time.Second)
    62  
    63  	setupUnit(target, conn, t)
    64  	linkUnit(target, conn, t)
    65  
    66  	reschan := make(chan string)
    67  	_, err = conn.StartUnit(target, "replace", reschan)
    68  	if err != nil {
    69  		t.Fatal(err)
    70  	}
    71  
    72  	job := <-reschan
    73  	if job != "done" {
    74  		t.Fatal("Couldn't start", target)
    75  	}
    76  
    77  	for {
    78  		select {
    79  		case changes := <-evChan:
    80  			tCh, ok := changes[target]
    81  
    82  			// Just continue until we see our event.
    83  			if !ok {
    84  				continue
    85  			}
    86  
    87  			if tCh.ActiveState == "active" && tCh.Name == target {
    88  				goto success
    89  			}
    90  		case err = <-errChan:
    91  			t.Fatal(err)
    92  		case <-time.After(10 * time.Second):
    93  			t.Fatal("Reached timeout")
    94  		}
    95  	}
    96  
    97  success:
    98  	return
    99  }
   100  
   101  // TestSubStateSubscription exercises the basics of sub-state event subscriptions
   102  func TestSubStateSubscription(t *testing.T) {
   103  	target := "subscribe-events.service"
   104  
   105  	conn, err := New()
   106  	defer conn.Close()
   107  	if err != nil {
   108  		t.Fatal(err)
   109  	}
   110  
   111  	updateCh := make(chan *SubStateUpdate, 256)
   112  	errCh := make(chan error, 256)
   113  	conn.SetSubStateSubscriber(updateCh, errCh)
   114  
   115  	setupUnit(target, conn, t)
   116  	linkUnit(target, conn, t)
   117  
   118  	reschan := make(chan string)
   119  	_, err = conn.StartUnit(target, "replace", reschan)
   120  	if err != nil {
   121  		t.Fatal(err)
   122  	}
   123  
   124  	job := <-reschan
   125  	if job != "done" {
   126  		t.Fatal("Couldn't start", target)
   127  	}
   128  
   129  	for {
   130  		select {
   131  		case update := <-updateCh:
   132  			if update.UnitName == target && update.SubState == "running" {
   133  				return // success
   134  			}
   135  		case err := <-errCh:
   136  			t.Fatal(err)
   137  		case <-time.After(10 * time.Second):
   138  			t.Fatal("Reached timeout")
   139  		}
   140  	}
   141  }
   142  
   143  // TestPropertiesSubscription exercises the basics of property change event subscriptions
   144  func TestPropertiesSubscription(t *testing.T) {
   145  	target := "subscribe-events.service"
   146  
   147  	conn, err := New()
   148  	defer conn.Close()
   149  	if err != nil {
   150  		t.Fatal(err)
   151  	}
   152  
   153  	err = conn.Subscribe()
   154  	if err != nil {
   155  		t.Fatal(err)
   156  	}
   157  
   158  	updateCh := make(chan *PropertiesUpdate, 256)
   159  	errCh := make(chan error, 256)
   160  	conn.SetPropertiesSubscriber(updateCh, errCh)
   161  
   162  	setupUnit(target, conn, t)
   163  	linkUnit(target, conn, t)
   164  
   165  	reschan := make(chan string)
   166  	_, err = conn.StartUnit(target, "replace", reschan)
   167  	if err != nil {
   168  		t.Fatal(err)
   169  	}
   170  
   171  	job := <-reschan
   172  	if job != "done" {
   173  		t.Fatal("Couldn't start", target)
   174  	}
   175  
   176  	for {
   177  		select {
   178  		case update := <-updateCh:
   179  			if update.UnitName == target {
   180  				subState, ok := update.Changed["SubState"].Value().(string)
   181  				if ok && subState == "running" {
   182  					return // success
   183  				}
   184  			}
   185  		case err := <-errCh:
   186  			t.Fatal(err)
   187  		case <-time.After(10 * time.Second):
   188  			t.Fatal("Reached timeout")
   189  		}
   190  	}
   191  }
   192
View as plain text