github.com/orofarne/hammy@v0.0.0-20130409105742-374fadfd6ecb/src/hammy/request_impl_test.go (about)

     1  package hammy
     2  
     3  import (
     4  	"testing"
     5  	"encoding/json"
     6  	"fmt"
     7  )
     8  
     9  type TriggersGetterTestImpl struct {
    10  }
    11  
    12  func (tg *TriggersGetterTestImpl) MGet(keys []string) (triggers map[string]string, err error) {
    13  	triggers = make(map[string]string)
    14  	for _, key := range keys {
    15  		triggers[key] = fmt.Sprintf("Trigger for key '%s'", key)
    16  	}
    17  	return
    18  }
    19  
    20  type StateKeeperTestImpl struct {
    21  	Data map[string]StateKeeperAnswer
    22  }
    23  
    24  func (sk *StateKeeperTestImpl) Generate(keys []string) {
    25  	sk.Data = make(map[string]StateKeeperAnswer)
    26  	for i, key := range keys {
    27  		cas := uint64(i + 100)
    28  		sk.Data[key] = StateKeeperAnswer{
    29  			State: State{},
    30  			Cas: &cas,
    31  			Err: nil,
    32  		}
    33  	}
    34  }
    35  
    36  func (sk *StateKeeperTestImpl) Get(key string) StateKeeperAnswer {
    37  	//fmt.Printf("StateKeeperTestImpl.Get(%#v)\n", key)
    38  
    39  	return sk.Data[key]
    40  }
    41  
    42  func (sk *StateKeeperTestImpl) MGet(keys []string) (ret map[string]StateKeeperAnswer) {
    43  	//fmt.Printf("StateKeeperTestImpl.MGet(%#v)\n", keys)
    44  
    45  	ret = make(map[string]StateKeeperAnswer)
    46  	for _, key := range keys {
    47  		ret[key] = sk.Data[key]
    48  	}
    49  	return
    50  }
    51  
    52  func (sk *StateKeeperTestImpl) Set(key string, data State, cas *uint64) (retry bool, err error) {
    53  	//fmt.Printf("StateKeeperTestImpl.Set(%#v, %#v, %#v)\n", key, data, cas)
    54  
    55  	s := sk.Data[key]
    56  
    57  	if *s.Cas == 101 {
    58  		(*s.Cas)++
    59  		sk.Data[key] = s
    60  	}
    61  
    62  	if *s.Cas != *cas {
    63  		return true, nil
    64  	}
    65  	s.State = data
    66  	(*s.Cas)++
    67  	sk.Data[key] = s
    68  	return false, nil
    69  }
    70  
    71  type ExecuterTestImpl struct {
    72  }
    73  
    74  func (e *ExecuterTestImpl) ProcessTrigger(key string, trigger string,
    75  	state *State, data IncomingHostData) (newState *State, cmdb *CmdBuffer, err error) {
    76  //
    77  	desired_trigger := fmt.Sprintf("Trigger for key '%s'", key)
    78  	if trigger != desired_trigger {
    79  		return nil, NewCmdBuffer(0), fmt.Errorf("Expected trigger is %#v, got %#v",
    80  			desired_trigger, trigger)
    81  	}
    82  	return state, NewCmdBuffer(0), nil
    83  }
    84  
    85  type CmdBufferProcessorTestImpl struct {
    86  }
    87  
    88  func (cbp *CmdBufferProcessorTestImpl) Process(key string, cmdb *CmdBuffer) error {
    89  	return nil
    90  }
    91  
    92  func TestRequestImplSimple(t *testing.T) {
    93  	sk := StateKeeperTestImpl{}
    94  	sk.Generate([]string{"host1", "host2"})
    95  
    96  	rh := RequestHandlerImpl{
    97  		TGetter: &TriggersGetterTestImpl{},
    98  		SKeeper: &sk,
    99  		Exec: &ExecuterTestImpl{},
   100  		CBProcessor: &CmdBufferProcessorTestImpl{},
   101  	}
   102  
   103  	rh.InitMetrics("request_impl_test_instance")
   104  
   105  	var data IncomingData
   106  	jsonTestData := `{
   107  		"host1": {
   108  			"key1.1": [{
   109  				"timestamp": 1361785778,
   110  				"value": 3.14
   111  			}]
   112  		},
   113  		"host2": {
   114  			"key2.1": [{
   115  				"timestamp": 1361785817,
   116  				"value": "test string"
   117  			}],
   118  			"key2.2": [{
   119  				"timestamp": 1361785858,
   120  				"value": 12345
   121  			},
   122  			{
   123  				"timestamp": 1361785927,
   124  				"value": 999.3
   125  			}]
   126  		}
   127  	}`
   128  	if err := json.Unmarshal([]byte(jsonTestData), &data); err != nil {
   129  		panic(err)
   130  	}
   131  
   132  	errs := rh.Handle(data)
   133  	for k, err := range errs {
   134  		if err != nil {
   135  			t.Fatalf("Error for key `%s`: %v", k, err)
   136  		}
   137  	}
   138  }