FilesExpand file tree

 master

/

about_proxy_object_project.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

187 lines (135 loc) · 5.41 KB

 master

/

about_proxy_object_project.py

Copy path

Top

File metadata and controls

• Code
• Blame

187 lines (135 loc) · 5.41 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# Project: Create a Proxy Class

#

# In this assignment, create a proxy class (one is started for you

# below). You should be able to initialize the proxy object with any

# object. Any attributes called on the proxy object should be forwarded

# to the target object. As each attribute call is sent, the proxy should

# record the name of the attribute sent.

#

# The proxy class is started for you. You will need to add a method

# missing handler and any other supporting methods. The specification

# of the Proxy class is given in the AboutProxyObjectProject koan.

# Note: This is a bit trickier that it's Ruby Koans counterpart, but you

# can do it!

from runner.koan import *

class Proxy(object):

def __init__(self, target_object):

object.__setattr__(self, '_messages', [])

object.__setattr__(self, '_obj', target_object)

def __setattr__(self, attr, value):

object.__getattribute__(self, '_messages').append(attr + "=")

object.__getattribute__(self, '_obj').__setattr__(attr, value)

def __getattribute__(self, attr):

if attr == 'messages':

return object.__getattribute__(self, 'messages')

if attr == 'was_called':

return object.__getattribute__(self, 'was_called')

if attr == 'number_of_times_called':

return object.__getattribute__(self, 'number_of_times_called')

object.__getattribute__(self, '_messages').append(attr)

result = object.__getattribute__(self, '_obj').__getattribute__(attr)

if 'instancemethod' == type(result).__name__:

return result.__call__

else:

return result

def messages(self):

return object.__getattribute__(self, '_messages')

def was_called(self, attr):

filtered_messages = filter(lambda attr: attr[:-1] if attr[-1] == '=' else attr, object.__getattribute__(self, '_messages'))

return attr in filtered_messages

def number_of_times_called(self, attr):

filtered_messages = filter(lambda elem: attr == elem, object.__getattribute__(self, '_messages'))

return len(filtered_messages)

# The proxy object should pass the following Koan:

#

class AboutProxyObjectProject(Koan):

def test_proxy_method_returns_wrapped_object(self):

# NOTE: The Television class is defined below

tv = Proxy(Television())

self.assertTrue(isinstance(tv, Proxy))

def test_tv_methods_still_perform_their_function(self):

tv = Proxy(Television())

tv.channel = 10

tv.power()

self.assertEqual(10, tv.channel)

self.assertTrue(tv.is_on())

def test_proxy_records_messages_sent_to_tv(self):

tv = Proxy(Television())

tv.power()

tv.channel = 10

self.assertEqual(['power', 'channel='], tv.messages())

def test_proxy_handles_invalid_messages(self):

tv = Proxy(Television())

ex = None

try:

tv.no_such_method()

except AttributeError as ex:

pass

self.assertEqual(AttributeError, type(ex))

def test_proxy_reports_methods_have_been_called(self):

tv = Proxy(Television())

tv.power()

tv.power()

self.assertTrue(tv.was_called('power'))

self.assertFalse(tv.was_called('channel'))

def test_proxy_counts_method_calls(self):

tv = Proxy(Television())

tv.power()

tv.channel = 48

tv.power()

self.assertEqual(2, tv.number_of_times_called('power'))

self.assertEqual(1, tv.number_of_times_called('channel='))

self.assertEqual(0, tv.number_of_times_called('is_on'))

def test_proxy_can_record_more_than_just_tv_objects(self):

proxy = Proxy("Py Ohio 2010")

result = proxy.upper()

self.assertEqual("PY OHIO 2010", result)

result = proxy.split()

self.assertEqual(["Py", "Ohio", "2010"], result)

self.assertEqual(['upper', 'split'], proxy.messages())

# ====================================================================

# The following code is to support the testing of the Proxy class. No

# changes should be necessary to anything below this comment.

# Example class using in the proxy testing above.

class Television(object):

def __init__(self):

self._channel = None

self._power = None

@property

def channel(self):

return self._channel

@channel.setter

def channel(self, value):

self._channel = value

def power(self):

if self._power == 'on':

self._power = 'off'

else:

self._power = 'on'

def is_on(self):

return self._power == 'on'

# Tests for the Television class. All of theses tests should pass.

class TelevisionTest(Koan):

def test_it_turns_on(self):

tv = Television()

tv.power()

self.assertTrue(tv.is_on())

def test_it_also_turns_off(self):

tv = Television()

tv.power()

tv.power()

self.assertFalse(tv.is_on())

def test_edge_case_on_off(self):

tv = Television()

tv.power()

tv.power()

tv.power()

self.assertTrue(tv.is_on())

tv.power()

self.assertFalse(tv.is_on())

def test_can_set_the_channel(self):

tv = Television()

tv.channel = 11

self.assertEqual(11, tv.channel)